Kotlin desde cero hasta experto

// Todo esto se explica capítulo por capítulo. Por ahora, disfruta la lectura.
data class Usuario(val nombre: String, val edad: Int) {
    val esMayorDeEdad get() = edad >= 18
}

fun main() {
    val usuarios = listOf(
        Usuario("Ana", 34),
        Usuario("Luis", 15),
    )

    usuarios
        .filter { it.esMayorDeEdad }
        .forEach { println("Hola $it") }
}

fun main() {
    println("Hola, mundo")
}

fun main() {
    val saludo = "Kotlin"
    val anio = 2026
    println("Aprendiendo $saludo en el año $anio")

    val args: Array<String> = arrayOf("Ana", "Luis") // lo que llegaría por línea de comandos
    println("Argumentos recibidos: ${args.size}")
}

// 1) Punto y coma OPCIONAL: solo si pones dos sentencias en una línea
val a = 1; val b = 2

// 2) Bloques con llaves; la indentación es convención (4 espacios)
fun saluda() {
    println("Hola")
}

// 3) Comentarios idénticos a Java/Dart
// una línea
/* un bloque
   multilínea */

// 4) Los nombres usan lowerCamelCase para variables y funciones
val precioFinal = 99.9
fun calculaTotal() {}

// 5) Las clases van en UpperCamelCase y los archivos pueden llamarse como sea
class Factura {}

val total = 100 +
    200            // OK: la línea termina en '+'

val lista = listOf(
    "a", "b",      // OK: dentro de paréntesis da igual
)

val `class` = "mala idea en general, pero legal"
val `in` = 42      // necesario a veces con librerías Java

const val IVA = 0.21              // constante global de compilación

fun main() {
    val nombre = "Ana"            // inferido: String
    var saldo = 100               // inferido: Int

    saldo += 50                   // OK: es var
    // nombre = "Otra"             // ERROR de compilación: val no reasignable

    // Tipado explícito opcional:
    val activo: Boolean = true
    var temperatura: Double = 21.5
}

val numeros = mutableListOf(1, 2, 3)

numeros.add(4)        // OK: el CONTENIDO puede cambiar
// numeros = mutableListOf()   // ERROR: la REFERENCIA no

class Servicio {
    lateinit var cliente: Cliente     // prometes inicializarla antes de usarla

    val cache: Map<String, Int> by lazy {   // se calcula SOLO la primera vez que se lee
        cargarDatosCostosos()
    }
}

val entero = 42                 // Int
val grande = 9_000_000_000L     // Long (los _ son solo legibilidad)
val decimal = 3.14159           // Double
val flotante = 2.5F             // Float
val hexa = 0xFF                 // literales hexadecimales y binarios:
val binario = 0b1010            //   255 y 10 respectivamente

println(entero + decimal)       // mezcla automática -> Double: 45.14159

val i: Int = 10
// val l: Long = i        // ERROR de compilación
val l: Long = i.toLong()  // OK
val d = l.toDouble()

println(7 / 2)             // 3    ¡división ENTERA trunca!
println(7.0 / 2)           // 3.5
println(-7.floorDiv(2))    // 4    división hacia abajo
println(-7.mod(3))         // 2    resto siempre positivo

val letra: Char = 'A'         // ¡comillas SIMPLES!
println(letra.code)           // 65  código Unicode
println('a'.uppercase())      // A
println('5'.isDigit())        // true
for (c in 'a'..'e') print(c)  // abcde  (los Char también forman rangos)

val conectado = true
val esAdmin = false

if (conectado && !esAdmin) println("Acceso limitado")

// && deja de evaluar si el primero es false:
val nombre: String? = null
if (nombre != null && nombre.length > 0) { /* seguro */ }

val nombre = "Ana"
val edad = 34

println("Hola, $nombre")                    // Hola, Ana
println("El año que viene cumplirás ${edad + 1}")  // expresiones completas
println("Objetos también: ${listOf(1, 2)}")       // [1, 2]

val s = "Kotlin es genial"

s.length               // 16
s[0]                   // 'K'   índice como corchetes
s.uppercase()          // KOTLIN ES GENIAL
s.replace("genial", "increíble")
s.substring(0, 6)      // Kotlin
s.split(" ")           // [Kotlin, es, genial]
s.trim()               // quita espacios en extremos
"ab".repeat(3)         // ababab
"-".padEnd(20, '=')    // -------------------  útil para menús
s.contains("es")       // true
"2026-08-22".startsWith("2026")  // true

val a = "kotlin"
val b = "KO".lowercase() + "TLIN".lowercase()

println(a == b)    // true   ¡contenido!
println(a === b)   // false  (aquí son objetos distintos)

val json = """
    {
        "usuario": "$nombre",
        "activo": true
    }
""".trimIndent()

println(json)
// {
//     "usuario": "Ana",
//     "activo": true
// }

val ruta = """C:\Users\ana\documentos"""   // sin escapar las contrabarras

val n = "123".toInt()          // 123
val x = "abc".toIntOrNull()    // null: NO explota, devuelve nulo (capítulo 16)

println("%.2f".format(3.14159))   // 3.14   formato tipo printf

val a = 7; val b = 2

a + b    // 9     también concatena Strings y colecciones
a - b    // 5
a * b    // 14
a / b    // 3     ¡entero! (capítulo 6)
a % b    // 1

// Comparación estilo matemático:
println(3 < 5)          // true
println("a".."z")       // los rangos hacen el resto de la magia ↓

// Creación
val unoACinco = 1..5            // 1, 2, 3, 4, 5   (¡incluye el final!)
val exclusivo  = 1 until 5      // 1, 2, 3, 4      (excluye el final)
val descendente = 5 downTo 1    // 5, 4, 3, 2, 1
const val paso = 2
val pares = 0..10 step paso     // 0, 2, 4, 6, 8, 10
val letras = 'a'..'e'

// Pertenencia con 'in'
if (edad in 18..65) println("Edad laboral")
if ('x' !in letras) println("fuera del abecedario inicial")

// Iteración (capítulo 10 lo amplía)
for (i in 1..3) print(i)        // 123

fun describe(x: Any): String =
    if (x is Int && x in 1..100) "entero pequeño"
    else if (x is String) "texto de ${x.length} letras"
    else "otra cosa"

println(describe(42))        // entero pequeño
println(describe("Kotlin"))  // texto de 6 letras

val edad = 20

// Sentencia normal:
if (edad >= 18) println("mayor de edad") else println("menor")

// EXPRESIÓN (el else es obligatorio si se asigna):
val categoria = if (edad < 13) "niño"
                else if (edad < 18) "adolescente"
                else "adulto"

fun clasifica(n: Int): String = when {
    n == 0 -> "cero"
    n in 1..9 -> "un dígito"
    n % 2 == 0 -> "par grande"
    else -> "impar grande"
}

// Con sujeto:
fun diaTipo(dia: String) = when (dia) {
    "sábado", "domingo" -> "fin de semana"
    "lunes" -> "principio duro"
    else -> "entre semana"
}

val nota = 87
val mencion = when {
    nota >= 90 -> "Sobresaliente"
    nota >= 70 -> "Notable"
    nota >= 60 -> "Aprobado"
    else -> "Suspenso"
}
println(mencion)   // Notable

// Rangos (capítulo 8)
for (i in 1..5) print("$i ")          // 1 2 3 4 5
println()

// Colecciones
val frutas = listOf("pera", "kiwi", "uva")
for (fruta in frutas) print("$fruta ") // pera kiwi uva
println()

// Con índice y valor a la vez:
for ((i, fruta) in frutas.withIndex()) println("$i: $fruta")

// Sobre un String:
for (c in "Kt") print(c + "-")         // K-t-

var intento = 1
while (intento <= 3) {
    println("Intento $intento")
    intento++
}

// do/while garantiza al menos una pasada:
do {
    println("se ejecuta una vez como mínimo")
    intento++
} while (false)

for (i in 1..5) {
    if (i == 3) continue     // salta el resto de ESTA iteración
    if (i == 5) break        // abandona el bucle entero
    print(i)                 // 124
}
println()

// Etiquetas para salir de bucles anidados de golpe:
busqueda@ for (fila in 1..3) {
    for (col in 1..3) {
        if (fila * col == 6) break@busqueda   // sale de AMBOS bucles
    }
}

val nums = listOf(1, 2, 3, 4)

// Estilo imperativo:
var suma = 0
for (n in nums) if (n % 2 == 0) suma += n

// Estilo funcional (el que usarás a diario):
val sumaFp = nums.filter { it % 2 == 0 }.sum()
println(sumaFp)   // 6 en ambos casos

// Sintaxis completa:  fun nombre(param: Tipo): TipoRetorno { ... }
fun suma(a: Int, b: Int): Int {
    return a + b
}

// Si el cuerpo es UNA expresión: llaves fuera y tipo inferido
fun multiplica(a: Int, b: Int) = a * b

fun saluda(nombre: String): Unit {   // Unit = "no devuelve nada", se omite
    println("Hola $nombre")
}

println(suma(2, 3))        // 5
println(multiplica(4, 5))  // 20

fun envia(destinatario: String, asunto: String, urgente: Boolean = false) {
    println("[$asunto] -> $destinatario ${if (urgente) "(URGENTE)" else ""}")
}

envia("ana@x.com", "Reunión")                       // usa el default
envia(asunto = "Fire!", destinatario = "soporte", urgente = true)

fun conecta(host: String, puerto: Int = 8080, ssl: Boolean = true) =
    println("$host:$puerto ${if (ssl) "https" else "http"}")

conecta("api.ejemplo.com")                 // https://api.ejemplo.com:8080
conecta("local", 3000, false)              // http://local:3000

fun procesaPedido(total: Double): Double {
    // función DENTRO de otra: ve sus parámetros, no contamina la clase
    fun aplicaIva(x: Double) = x * 1.21

    val conIva = aplicaIva(total)
    return if (conIva > 100) conIva * 0.95 else conIva   // descuento grande
}

println(procesaPedido(200.0))   // 230.0 * 0.95 = 218.5

fun maximo(vararg numeros: Int): Int {
    var mejor = Int.MIN_VALUE
    for (n in numeros) if (n > mejor) mejor = n
    return mejor
}

println(maximo(3, 9, 4))       // 9
println(maximo())              // -2147483648 (caso vacío: ¡documéntalo!)

val datos = intArrayOf(5, 7, 6)
println(maximo(*datos))        // el operador * «expande» el array

fun area(lado: Double) = lado * lado
fun area(base: Double, altura: Double) = base * altura

println(area(2.0))          // 4.0
println(area(2.0, 3.0))     // 6.0

class Potencia(val base: Int) {
    infix fun elevadoA(exponente: Int) = base.toDouble().pow(exponente)
}
// infix permite llamar sin punto ni paréntesis:
val p = Potencia(2) elevadoA 8      // 256.0

// Sobrecargar operadores aritméticos para TU tipo:
data class Vector(val x: Int, val y: Int) {
    operator fun plus(otro: Vector) = Vector(x + otro.x, y + otro.y)
}
println(Vector(1, 2) + Vector(3, 4))   // Vector(x=4, y=6)

// Tipo: (parámetros) -> retorno
val cuadrado: (Int) -> Int = { n -> n * n }

// Con tipos inferidos:
val cubo = { n: Int -> n * n * n }

println(cuadrado(5))   // 25
println(cubo(3))       // 27

// Parámetro único implícito: it
val doble: (Int) -> Int = { it * 2 }
println(doble(21))     // 42

// Sin parámetros ni retorno útil:
val ping = { println("ping") }

fun opera(a: Int, b: Int, operacion: (Int, Int) -> Int): Int =
    operacion(a, b)

println(opera(6, 2) { x, y -> x + y })   // 8
println(opera(6, 2) { x, y -> x - y })   // 4

// Si el ÚLTIMO parámetro es una lambda, sale fuera del paréntesis
// (trailing lambda): la sintaxis más usada en Kotlin real.

fun esPar(n: Int) = n % 2 == 0

val nums = listOf(1, 2, 3, 4)
println(nums.filter(::esPar))    // [2, 4]
println(nums.map(Int::toString)) // [1, 2, 3, 4]  referencia de clase

fun contador(): () -> Int {
    var cuenta = 0
    return { ++cuenta }          // captura `cuenta` aunque la función ya terminó
}

val siguiente = contador()
println(siguiente())   // 1
println(siguiente())   // 2
println(siguiente())   // 3

inline fun cronometra(bloque: () -> Unit) {
    val inicio = System.nanoTime()
    bloque()
    println("tardó ${(System.nanoTime() - inicio) / 1000} µs")
}

// Creación
val soloLectura = listOf("a", "b")           // List<String>
val mutable      = mutableListOf(1, 2, 3)    // MutableList<Int>

// Acceso
val frutas = listOf("pera", "kiwi", "uva")
frutas[0]         // pera
frutas.first()    // pera
frutas.last()     // uva
frutas.getOrNull(9)   // null: sin excepción (capítulo 16)
frutas.size       // 3

// Mutaciones (solo en MutableList):
mutable.add(4)
mutable.removeAt(0)
mutable += listOf(5, 6)     // azúcar para addAll
mutable[0] = 99

// frutas.add(...)   // ERROR: List no tiene add. El compilador te protege.

data class Producto(val nombre: String, val precio: Double, val stock: Int)

val catalogo = listOf(
    Producto("Teclado", 45.0, 12),
    Producto("Ratón", 25.5, 0),
    Producto("Monitor", 199.0, 3),
)

catalogo.filter { it.stock > 0 }              // quédate con los que cumplen
        .sortedByDescending { it.precio }     // ordena descendente
        .map { it.nombre }                    // transforma a otro tipo
        .forEach(::println)                   // Monitor, Teclado

val precios = listOf(45.0, 25.5, 199.0)

precios.sum()                       // 269.5
precios.maxOrNull()                 // 199.0
precios.average()                   // 89.83...
precios.fold(100.0) { acc, p -> acc + p }   // 369.5: acumulador inicial

catalogo.find { it.nombre == "Ratón" }      // primer que cumpla o null
catalogo.any { it.stock == 0 }              // true: ¿hay alguno?
catalogo.all { it.precio > 20 }             // true: ¿cumplen todos?
catalogo.count { it.stock > 0 }             // 2
catalogo.groupBy { it.stock > 0 }           // Map>

val vocales = setOf('a', 'e', 'i')            // LinkedHashSet por debajo
val mutables = mutableSetOf("rojo", "verde")

mutables.add("azul")
mutables.add("azul")          // duplicado: se ignora silenciosamente
println(mutables.size)        // 3

// Operaciones de conjuntos:
val a = setOf(1, 2, 3)
val b = setOf(3, 4, 5)

a union b             // [1, 2, 3, 4, 5]
a intersect b         // [3]
a subtract b          // [1, 2]

val visitados = mutableSetOf()
if ("pagina2" in visitados) println("ya la viste")   // pertenencia O(1)

// Creación con pares o con el DSL «to»:
val capitales = mapOf(
    "España" to "Madrid",
    "Francia" to "París",
)

val stock = mutableMapOf(
    "teclado" to 12,
    "ratón" to 30,
)

// Lectura
capitales["España"]              // Madrid
capitales["Italia"]              // null (¡no excepción!)
capitales.getOrDefault("Italia", "?")   // ?
capitales.containsKey("Francia") // true
capitales.keys; capitales.values

// Escritura
stock["monitor"] = 5             // insertar o actualizar
stock.putIfAbsent("webcam", 7)
stock.merge("teclado", -1, Int::plus)   // 11: suma sobre el valor actual

for ((pais, capital) in capitales) {
    println("$capital es la capital de $pais")
}

val precios = mapOf("café" to 1.5, "té" to 1.2)
precios.mapValues { (_, precio) -> precio * 1.21 }   // aplica IVA
precios.filterKeys { it == "té" }

// Agrupar una lista EN un map (patrón muy común en apps reales):
data class Persona(val nombre: String, val ciudad: String)
val gente = listOf(
    Persona("Ana", "Madrid"), Persona("Luis", "Barcelona"),
    Persona("Eva", "Madrid"),
)
println(gente.groupBy { it.ciudad })
// {Madrid=[Ana, Eva], Barcelona=[Luis]}

var nombre: String = "Ana"
// nombre = null        // ERROR: String NO admite nulos

var apodo: String? = null     // el interrogante lo permite
apodo = "anita"

val longitud1 = nombre.length      // OK garantizado
// val longitud2 = apodo.length    // ERROR: podría ser null

val apodo: String? = null

println(apodo?.length)    // null   (no explota: propaga el nulo)
// Encadenable:
// pedido?.cliente?.direccion?.ciudad

val apodo: String? = null

val mostrado = apodo ?: "anónimo"       // si es null, usa el valor alternativo
println(mostrado)                        // anónimo

// Combinado (patrón diario):
val largo = (apodo ?: "").length         // 0

// También puede lanzar o retornar:
fun saluda(usuario: String?) =
    println("Hola ${usuario ?: return}")  // sale si no hay usuario

fun imprimeEnMayusculas(texto: String?) {
    if (texto != null) {
        println(texto.uppercase())   // ¡sin ! ni conversión!
    }                                // dentro del if el compilador SABE que no es null
}

// Con retorno anticipado queda aún más limpio:
fun procesa(datos: String?): Int {
    val d = datos ?: return 0        // guard clause idiomática
    return d.length                  // d ya es String normal
}

val email: String? = obtenerEmail()

email?.let { enviarBienvenida(it) }      // solo se ejecuta si no es null
// equivalente legible a:
if (email != null) { enviarBienvenida(email) }

val configuracion: String? = cargar()

val c = configuracion!!    // "confío en que no es null"
                           // si te equivocas: KotlinNullPointerException EN TIEMPO DE EJECUCIÓN

fun registra(id: Int) {
    val usuario = buscar(id)
    // lanza IllegalStateException con mensaje claro si viene null:
    val u = requireNotNull(usuario) { "El usuario $id debe existir" }
    println(u.nombre)
}
// primos útiles: checkNotNull() para invariantes, error("mensaje") para fallos deliberados

class CuentaBancaria(val titular: String) {
    var saldo: Double = 0.0
        private set                 // solo la propia clase puede modificarlo

    fun deposita(cantidad: Double) {
        require(cantidad > 0) { "La cantidad debe ser positiva" }
        saldo += cantidad
    }

    fun retira(cantidad: Double): Boolean {
        if (cantidad > saldo) return false
        saldo -= cantidad
        return true
    }
}

fun main() {
    val c = CuentaBancaria("Ana")    // ¡sin new!
    c.deposita(500.0)

    println("${c.titular}: ${c.saldo}€")   // Ana: 500.0€
    println(c.retira(200.0))               // true
    // c.saldo = 999999.0                  // ERROR: setter privado
}

class Rectangulo(val ancho: Double, val alto: Double) {
    val area get() = ancho * alto           // propiedad CALCULADA
    val perimetro: Double
        get() = 2 * (ancho + alto)
}

val r = Rectangulo(3.0, 4.0)
println(r.area)      // 12.0  — se ve como campo, se calcula al vuelo

class Persona(val nombre: String, var edad: Int) {
    init {
        require(edad >= 0) { "La edad no puede ser negativa" }
        println("Nace $nombre")
    }
}

val p = Persona("Ana", 34)
// Persona("Luis", -5)   // IllegalArgumentException: La edad no puede ser negativa

class Pizza(
    val tamano: String = "mediana",
    val quesoExtra: Boolean = false,
    val bordeRelleno: Boolean = false,
)

val miPizza = Pizza(quesoExtra = true)   // nombrados + defaults

class Punto(val x: Int, val y: Int) {

    constructor(texto: String) : this(
        texto.substringBefore(',').trim().toInt(),
        texto.substringAfter(',').trim().toInt(),
    )

    override fun toString() = "Punto($x, $y)"
}

println(Punto("10, 20"))   // Punto(10, 20)

class Usuario private constructor(val email: String) {
    companion object {
        fun desdeEmail(email: String): Usuario? =
            if ("@" in email) Usuario(email) else null
    }
}

Usuario.desdeEmail("ana@x.com")   // Usuario@...
Usuario.desdeEmail("no-valido")   // null

class Temperatura {
    var celsius: Double = 20.0
        set(valor) {
            require(valor >= -273.15) { "Bajo el cero absoluto" }
            field = valor          // field = el campo de respaldo oculto
        }

    val fahrenheit get() = celsius * 9 / 5 + 32
}

val t = Temperatura()
t.celsius = 100.0
println(t.fahrenheit)   // 212.0
// t.celsius = -300.0   // IllegalArgumentException

import kotlin.properties.Delegates

class Configuracion {
    val api: String by lazy { cargarApiCostosa() }   // solo al primer uso

    var tema: String by Delegates.observable("claro") { _, viejo, nuevo ->
        println("Tema: $viejo -> $nuevo")            // reacciona a cambios
    }
}

val c = Configuracion()
c.tema = "oscuro"     // Tema: claro -> oscuro

class Json(val datos: Map<String, Any>) {
    val nombre: String   by datos
    val edad: Int        by datos
}

val j = Json(mapOf("nombre" to "Ana", "edad" to 34))
println("${j.nombre} tiene ${j.edad} años")   // Ana tiene 34 años

interface Sonido { fun reproduce(): String }
class Mp3 : Sonido { override fun reproduce() = "♪ mp3" }

// ReproductorLog «envuelve» a otro Sonido sin reescribir sus métodos:
class ReproductorLog(private val base: Sonido) : Sonido by base {
    override fun reproduce() = "LOG: ${base.reproduce()}"
}

data class Punto(val x: Int, val y: Int)

val p1 = Punto(1, 2)
val p2 = Punto(1, 2)

println(p1 == p2)       // true  ¡contenido!
println(p1)             // Punto(x=1, y=2)
println(p1.component1())// 1     acceso posicional

// copy: crea variaciones inmutables
val movido = p1.copy(x = 10)
println(movido)         // Punto(x=10, y=2)

val (x, y) = Punto(7, 3)
println(x + y)                    // 10

for ((nombre, precio) in mapOf("café" to 1.5)) println("$nombre: $precio")
val (min, max) = 3..9             // ¡los rangos también se destructuran!

// Estado de UI típico en Android moderno:
data class UiState(
    val cargando: Boolean = false,
    val usuarios: List<String> = emptyList(),
    val error: String? = null,
)

fun reduce(estado: UiState): UiState =
    estado.copy(cargando = false, usuarios = listOf("Ana"))

open class Animal(val nombre: String) {
    open fun sonido(): String = "..."

    fun duerme() = "$nombre duerme"    // NO open: idéntico para todos
}

class Perro(nombre: String) : Animal(nombre) {
    override fun sonido() = "¡Guau!"
}

class Gato(nombre: String, val vivo: Int = 9) : Animal(nombre) {
    override fun sonido() = "Miau"
    final override fun toString() = "Gato($nombre)"   // cierra de nuevo
}

val zoo = listOf(Perro("Rex"), Gato("Mishi"))
zoo.forEach { println("${it.nombre}: ${it.sonido()}") }

open class Notificacion(val mensaje: String) {
    open fun envia() = println("[base] $mensaje")
}

class Email(mensaje: String, val destino: String) : Notificacion(mensaje) {
    override fun envia() {
        super.envia()                       // reutiliza el comportamiento base
        println("       enviado a $destino")
    }
}

Email("Bienvenida", "ana@x.com").envia()

interface Volador {
    val altitudMax: Int                     // propiedad abstracta
    fun vuela() = "vuelo hasta ${altitudMax}m"   // implementación por defecto
}

interface Nadador {
    fun nada() = "nada como pez"
}

class Pato : Volador, Nadador {
    override val altitudMax = 1000
    // vuela() y nada() vienen gratis; solo implementa lo que difiera
}

abstract class Reporte(val titulo: String) {
    private val pasos = mutableListOf<String>()

    protected abstract fun generaLineas(): List<String>   // obligatorio

    fun renderiza(): String {                             // plantilla común
        pasos += "inicio"
        val cuerpo = generaLineas()
        pasos += "fin"
        return "# $titulo\n" + cuerpo.joinToString("\n")
    }
}

class ReporteVentas(titulo: String, private val ventas: List<Double>) :
    Reporte(titulo) {

    override fun generaLineas() = listOf(
        "Total: ${ventas.sum()}",
        "Media: ${ventas.average()}",
    )
}

println(ReporteVentas("Agosto", listOf(100.0, 250.0)).renderiza())

sealed interface Resultado<out T> {
    data class Exito<T>(val datos: T) : Resultado<T>
    data class Error(val mensaje: String) : Resultado<Nothing>
    object Cargando : Resultado<Nothing>
}

fun maneja(r: Resultado<String>): String = when (r) {
    is Resultado.Exito    -> "OK: ${r.datos}"
    is Resultado.Error    -> "FALLO: ${r.mensaje}"
    Resultado.Cargando    -> "esperando…"
    // ¡sin rama else! El compilador verifica que cubres TODO.
}

fun divide(a: Double, b: Double): Resultado<Double> =
    if (b != 0.0) Resultado.Exito(a / b)
    else Resultado.Error("División por cero")

println(maneja(divide(10.0, 4.0)))   // OK: 2.5
println(maneja(divide(1.0, 0.0)))    // FALLO: División por cero

// MAL (flags sueltos): cargando=true y error="x" ¿a la vez?
// BIEN (sealed): cada estado es exactamente UNO:
sealed interface UiState {
    data object Vacia : UiState
    data class Cargada(val items: List<String>) : UiState
    data class Fallida(val causa: Throwable) : UiState
}

fun area(figura: Figura): Double = when (figura) {
    is Circulo   -> Math.PI * figura.radio * figura.radio   // figura ya es Circulo aquí
    is Rectangulo -> figura.base * figura.altura
}

sealed interface Figura
data class Circulo(val radio: Double) : Figura
data class Rectangulo(val base: Double, val altura: Double) : Figura

println(area(Circulo(1.0)))       // 3.14159...
println(area(Rectangulo(3.0, 2.0)))  // 6.0

object ConfigGlobal {
    var debug: Boolean = false
    val inicio: Long = System.currentTimeMillis()
}

ConfigGlobal.debug = true     // una única instancia, creada perezosamente

class Sesion private constructor(val usuario: String) {
    companion object {
        const val MAX_INTENTOS = 3                 // constante real
        private var actual: Sesion? = null

        fun inicia(usuario: String): Sesion =
            actual ?: Sesion(usuario).also { actual = it }
    }
}

Sesion.MAX_INTENTOS                    // acceso tipo estático
val s = Sesion.inicia("ana")

interface ClickListener { fun onClick(x: Int, y: Int) }

boton.registra(object : ClickListener {
    override fun onClick(x: Int, y: Int) = println("Click en ($x,$y)")
})

// Con interfaces de UN método, mejor una lambda:
boton.registra { x, y -> println("Click en ($x,$y)") }

sealed interface Estado
data object SinConexion : Estado      // imprime "SinConexion", no la clase+hash

println(Estado.SinConexion)   // SinConexion

enum class Prioridad(val nivel: Int) {
    BAJA(1), MEDIA(2), ALTA(3), CRITICA(9);

    fun esUrgente() = nivel >= 3
}

val p = Prioridad.ALTA
println(p.nivel)          // 3
println(p.esUrgente())    // true
println(Prioridad.values().size)   // 4   (o Prioridad.entries, más moderno)
println(Prioridad.valueOf("MEDIA")) // MEDIA (lanza si no existe)

enum class Operacion {
    SUMAR { override fun aplica(a: Double, b: Double) = a + b },
    RESTAR { override fun aplica(a: Double, b: Double) = a - b };

    abstract fun aplica(a: Double, b: Double): Double
}

println(Operacion.SUMAR.aplica(2.0, 3.0))   // 5.0

for (op in Operacion.entries) print("${op.name} ")   // SUMAR RESTAR

val urgente = Prioridad.entries.firstOrNull { it.esUrgente() }
val porNivel = Prioridad.entries.sortedBy { it.nivel }

// Sintaxis: fun TipoReceptor.nombreFuncion(...)
fun String.saluda(): String = "¡Hola, $this!"

println("Ana".saluda())          // ¡Hola, Ana!
// como si String hubiera nacido con ese método

// Formatear dinero:
fun Double.aEuros(): String = "%.2f €".format(this)
println(1234.5.aEuros())                    // 1234,50 €

// Validar email:
fun String?.esEmailValido(): Boolean =
    this != null && Regex(".+@.+\\..+").matches(this)

println("a@b.com".esEmailValido())          // true
println(null.esEmailValido())               // false  ¡extiende también el tipo anulable!

// Propiedades de extensión:
val String.inicial: Char get() = first()

// Genéricas:
fun <T> List<T>.segundaAlternativa(): T? = getOrNull(1)

class A { fun hola() = "miembro" }

fun A.hola() = "extensión"
A().hola()     // "miembro" — la clase siempre gana

// Archivo Util.kt
package com.miapp.util
fun String.quitaAcentos(): String = ...   // pública, importable en todo el proyecto

class Procesador {
    private fun String.normaliza() = trim().lowercase()   // solo visible aquí dentro
}

// Función genérica:
fun <T> primero(lista: List<T>): T = lista.first()

println(primero(listOf(1, 2)))         // 1
println(primero(listOf("a", "b")))     // a

// Clase genérica: una caja para cualquier tipo
class Caja<T>(private val valor: T) {
    fun saca(): T = valor
}

val cInt = Caja(42)
val cStr = Caja("hola")
println(cInt.saca() + 1)    // 43  — el tipo viaja intacto

// Varios parámetros y restricciones:
fun <K, V> Map<K, V>.describe() = "$K claves"   // (ilustrativo)

fun <T : Comparable<T>> maximo(a: T, b: T): T =
    if (a > b) a else b        // T debe poder compararse consigo mismo

println(maximo(3, 7))          // 7
println(maximo("pera", "kiwi")) // pera

interface Fuente<out T> { fun dame(): T }       // solo PRODUCE T → covariante (out)
class FuenteNums : Fuente<Number> { override fun dame(): Number = 42 }

val fuente: Fuente<Any> = FuenteNums()   // OK: Number "es un" Any al producirlo

interface Sumidero<in T> { fun recibe(x: T) }    // solo CONSUME T → contravariante (in)

fun cuentaStrings(lista: List<*>) = lista.count { it is String }

// reified conserva el tipo en tiempo de ejecución (solo inline):
inline fun <reified T : Any> Gson.fromJson(json: String): T = ...

val usuario: Usuario = gson.fromJson(json)   // ¡sin pasar Usuario::class.java!

fun leeEdad(texto: String): Int {
    return try {
        texto.toInt()
    } catch (e: NumberFormatException) {
        -1
    }
}

// try como EXPRESIÓN (devuelve valor):
val dividir = try { 10 / 2 } catch (e: ArithmeticException) { 0 }
println(dividir)   // 5

fun procesaArchivo(ruta: String) {
    var canal: java.nio.channels.FileChannel? = null
    try {
        // ... abrir y procesar ...
        throw IllegalStateException("archivo corrupto")
    } catch (e: java.io.IOException) {
        println("E/S falló: ${e.message}")
    } catch (e: Exception) {
        println("Error genérico: ${e.message}")
    } finally {
        println("cerrando recursos SIEMPRE")   // incluso si hubo excepción o return
    }
}

class SaldoInsuficienteException(val faltante: Double) :
    Exception("Faltan $faltante €")

fun retira(saldo: Double, cantidad: Double) {
    if (cantidad > saldo) throw SaldoInsuficienteException(cantidad - saldo)
}

try {
    retira(50.0, 80.0)
} catch (e: SaldoInsuficienteException) {
    println(e.message)     // Faltan 30.0 €
}

// runCatching envuelve cualquier bloque en Result:
val resultado = runCatching { "abc".toInt() }

resultado.isSuccess            // false
resultado.getOrNull()          // null
resultado.exceptionOrNull()?.message

resultado.fold(
    onSuccess = { println("número: $it") },
    onFailure = { println("falló: ${it::class.simpleName}") },
)
// Combinado con sealed classes (capítulo 23) forma el patrón dominante en apps.

fun registra(usuario: String?, edad: Int) {
    requireNotNull(usuario) { "usuario obligatorio" }  // IllegalArgumentException
    require(edad in 0..130) { "edad imposible: $edad" }
    check(!usuario.isBlank()) { "usuario vacío" }      // IllegalStateException
}

data class Persona(var nombre: String = "", var edad: Int = 0)

// apply — configurar y seguir usándolo:
val ana = Persona().apply {
    nombre = "Ana"          // this.nombre implícito
    edad = 34
}
println(ana)                // Persona(nombre=Ana, edad=34)

// also — log sin interrumpir la cadena:
listOf(1, 2, 3).also { println("procesando $it") }.map { it * 2 }

// let — solo si no es null (capítulo 16):
val email: String? = "a@b.com"
email?.let { enviarA(it) }

// run — calcula y devuelve:
val resumen = ana.run { "$nombre ($edad años)" }
println(resumen)            // Ana (34 años)

// with — agrupación legible:
with(StringBuilder()) {
    append("línea 1\n"); append("línea 2")
    println(toString())
}

import kotlinx.coroutines.*
import java.time.LocalTime

fun ahora() = LocalTime.now().toLocalTime().substring(0, 8)

fun main() = runBlocking {                 // puente para programas normales
    println("${ahora()} empiezo")

    launch {                               // «lanza y olvida»
        delay(1000)                        // NO bloquea el hilo: lo suspende
        println("${ahora()} terminó la tarea A")
    }

    val deferred = async {                 // devuelve un valor futuro
        delay(500)
        42
    }

    val resultado = deferred.await()       // espera el valor
    println("${ahora()} async devolvió $resultado")
}

suspend fun descargaUsuario(id: Int): String {
    delay(300)                       // simula red
    return "Usuario$id"
}

suspend fun cargaPerfil() {
    // Secuencial: 600 ms
    val u1 = descargaUsuario(1)
    val u2 = descargaUsuario(2)

    // Paralelo: ~300 ms — dos corutinas a la vez
    coroutineScope {
        val d1 = async { descargaUsuario(3) }
        val d2 = async { descargaUsuario(4) }
        println("${d1.await()} y ${d2.await()}")
    }
}

withContext(Dispatchers.IO) {        // red/disco: pool grande
    val datos = leeArchivoGrande()
}

val imagen = withContext(Dispatchers.Default) {   // CPU intensiva
    procesaPixeles(datos)
}

launch(Dispatchers.Main) {           // Android/UI: el hilo principal
    textView.text = "listo"
}

// Cambiar de contexto es barato y legible:
suspend fun cargaYProcesa() {
    val crudo = withContext(Dispatchers.IO) { bajaJson() }
    val modelo = withContext(Dispatchers.Default) { parsea(crudo) }
    withContext(Dispatchers.Main) { pinta(modelo) }
}

fun main() = runBlocking {
    val padre = launch {
        launch { delay(10_000); println("hijo 1") }   // hereda el ciclo del padre
        launch { delay(10_000); println("hijo 2") }
        println("padre activo")
    }
    delay(100)
    padre.cancel()            // cancela TAMBIÉN a los hijos
    println("fin")            // los hijos nunca imprimen
}

withTimeout(2_000) {           // TimeoutCancellationException si excede
    descargaLenta()
}

// o mejor, un valor por defecto:
val datos = withTimeoutOrNull(2_000) { descargaLenta() } ?: CACHE_LOCAL

var contador = 0                       // MAL: condición de carrera

val contadorSeguro = AtomicInteger(0)  // atómico simple

// O confina todo a UN contexto:
val scope = CoroutineScope(Dispatchers.Default + SupervisorJob())
scope.launch { /* único dueño del estado mutable */ }

import kotlinx.coroutines.*
import kotlinx.coroutines.flow.*

fun ticTac(): Flow<Int> = flow {
    for (i in 1..3) {
        delay(200)            // trabajo suspendido entre emisiones
        emit(i)               // publica un valor
    }
}

fun main() = runBlocking {
    ticTac().collect { valor ->
        println("recibido $valor")
    }
}

tictac
ticTac()
    .filter { it % 2 == 1 }         // solo impares
    .map { it * 10 }                // transforma
    .onEach { println("emitido $it") }
    .take(2)                        // primeros dos y cancela la fuente
    .collect { ... }

// StateFlow: SIEMPRE tiene un valor actual — ideal para pantalla:
private val _estado = MutableStateFlow(UiState())
val estado: StateFlow<UiState> = _estado.asStateFlow()   // lectura externa

fun carga() = scope.launch {
    _estado.value = UiState(cargando = true)
    val datos = repositorio.descarga()
    _estado.value = UiState(usuarios = datos)
}

// sharedFlow: eventos sin valor inicial (toasts, navegación):
private val _eventos = MutableSharedFlow<Evento>()
val eventos = _eventos.asSharedFlow()

// build.gradle.kts de una app JVM:
plugins {
    kotlin("jvm") version "2.1.0"
    application                       // añade tareas run/installDist
}

group = "com.miapp"
version = "1.0.0"

repositories { mavenCentral() }       // dónde buscar dependencias

dependencies {
    implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.9.0")
    testImplementation(kotlin("test"))   // kotlin.test para pruebas
}

application { mainClass.set("MainKt") }   // clase generada con tu fun main

import kotlinx.serialization.json.Json

val json = Json.encodeToString(mapOf("ok" to true))   // con kotlinx-serialization-json

import java.time.LocalDate
import java.time.LocalDateTime
import java.time.format.DateTimeFormatter

val hoy = LocalDate.now()
val cita = LocalDate.of(2026, 12, 24)

println(cita.dayOfWeek)                 // THURSDAY
println(cita.plusDays(7))               // 2026-12-31
println(hoy.isBefore(cita))             // true

val fmt = DateTimeFormatter.ofPattern("dd/MM/yyyy HH:mm")
println(LocalDateTime.now().format(fmt))     // 22/08/2026 17:45
println(LocalDate.parse("01/03/2027", DateTimeFormatter.ofPattern("dd/MM/yyyy")))

val patron = Regex("""\d{2}/\d{2}/\d{4}""")   // raw string sin dobles contrabarras

println(patron.matches("22/08/2026"))         // true (coincidencia completa)
println(patron.containsMatchIn("vence el 01/01/2027"))   // true
println(patron.findAll(texto).map { it.value }.toList())

// Reemplazo con grupos:
val tel = Regex("""(\d{3})-(\d{4})""")
println(tel.replace("llama al 555-1234") { "(${it.groupValues[1]}) ${it.groupValues[2]}" })
// llama al (555) 1234

import java.io.File

File("notas.txt").writeText("primera línea\n")
File("notas.txt").appendText("segunda\n")

println(File("notas.txt").readText())
File("notas.txt").readLines().forEachIndexed { i, l -> println("$i: $l") }

// Recorrido recursivo:
File(".").walkTopDown()
    .filter { it.extension == "kt" }
    .take(5)
    .forEach(::println)

// build.gradle.kts:
// plugins { kotlin("plugin.serialization") version "2.1.0" }
// dependencies { implementation("org.jetbrains.kotlinx:kotlinx-serialization-json:1.7.3") }

import kotlinx.serialization.Serializable
import kotlinx.serialization.json.Json

@Serializable
data class Articulo(val titulo: String, val precio: Double)

val texto = """{"titulo":"Libro","precio":19.9}"""
val art = Json.decodeFromString<Articulo>(texto)
println(art.precio)                          // 19.9
println(Json.encodeToString(art.copy(precio = 25.0)))

// src/main/kotlin/Calculadora.kt
class Calculadora {
    fun divide(a: Double, b: Double): Double {
        require(b != 0.0) { "división por cero" }
        return a / b
    }
}

// src/test/kotlin/CalculadoraTest.kt
import kotlin.test.*

class CalculadoraTest {
    private val calc = Calculadora()

    @Test
    fun `divide numeros normales`() = assertEquals(2.5, calc.divide(10.0, 4.0))

    @Test
    fun `divide por cero lanza`() {
        val ex = assertFailsWith<IllegalArgumentException> { calc.divide(1.0, 0.0) }
        assertTrue(ex.message!!.contains("cero"))
    }

    @Test
    fun `precision de coma flotante con delta`() =
        assertEquals(0.3, 0.1 + 0.2, absoluteTolerance = 1e-9)
}

class RepositorioTest {
    @BeforeTest fun prepara() { /* datos frescos por test */ }
    @AfterTest  fun limpia()  { /* cierra recursos */ }
}

// Para suspend fun: runTest (kotlinx-coroutines-test)
@Test fun `carga usuario`() = runTest {
    val u = repositorio.usuario(1)
    assertEquals("Ana", u.nombre)
}

import java.util.HashMap

val mapa = HashMap<String, Int>()   // tipos genéricos Java, sintaxis Kotlin
mapa.put("a", 1)

// Los getters/setters Java se ven como propiedades:
val calendario = java.util.Calendar.getInstance()
println(calendario.time)             // getTime() -> propiedad .time

val lista = java.util.ArrayList<String>()
lista += "desde Kotlin"              // operadores mapeados a add()

val nombreJava: String? = apiJava.getNombre()   // defensivo (recomendado)
val seguro = nombreJava ?: "invitado"

@file:JvmName("StringUtils")     // nombre de clase Java amigable

class Cofre(private val secreto: String) {
    @JvmField val id = 7                    // campo público directo

    companion object {
        @JvmStatic fun fabrica() = Cofre("x")   // static real para Java
    }
}

// Los métodos Java con firma especial se usan como operadores:
val sb = StringBuilder("abc")
sb += "def"                 // append()

for ((i, c) in "texto".withIndex()) {}   // Iterable de Java: for-each natural

// SAM conversion: interfaz Java de un método ← lambda directa
boton.addActionListener { e -> println("pulsado") }

// ❌ Java disfrazado:
val lista: MutableList<Int> = ArrayList()
for (i in 0 until 10) {
    if (i % 2 == 0) {
        lista.add(i * i)
    }
}

// ✅ Kotlin idiomático:
val cuadrados = (0..9).filter { it % 2 == 0 }.map { it * it }

// ❌ Nulos a la Java:
if (usuario != null && usuario.email != null) {
    enviar(usuario.email)
}

// ✅ Encadenado seguro:
usuario?.email?.let(::enviar)

// ❌ Builder manual con setters:
val cfg = Config()
cfg.host = "x"; cfg.puerto = 8080

// ✅ apply + defaults + data class:
val cfg = Config(host = "x").apply { puerto = 8080 }