7. Tipos funcionales, lambdas y eventos
En muchos programas hay que pasar a una función no datos, sino un comportamiento: el criterio de ordenación, la condición de filtrado o la acción que debe realizarse cuando ocurre algo. Kotlin responde a esta necesidad tratando las funciones como valores igual que cualquier otro: una función tiene un tipo, el tipo funcional, que se denota, por ejemplo, como [(Int, Int) -> Int]; puede almacenarse en una variable, pasarse como parámetro, devolverse como resultado de otra función y ejecutarse cuando se desee. Una función que recibe o devuelve una función se denomina función de orden superior.
Java, como recordatorio, no tiene tipos funcionales: se apoya en las interfaces funcionales, interfaces con un único método abstracto ([Runnable], [Comparator], [Function<T, R>]…), y solo a partir de Java 8 (2014) permitió implementarlas mediante expresiones lambda y referencias a métodos. Kotlin admite las lambdas desde su primera versión y también puede trabajar con las interfaces funcionales de Java, ya que utiliza directamente las bibliotecas de Java. Ya hemos usado lambdas ampliamente sin entrar en detalles, en las operaciones sobre colecciones del capítulo 5: en [persons.filter { it.age >= 18 }], pasamos una lambda a la función [filter]. Este capítulo explica qué hay detrás de esta sintaxis. Concluye con los eventos, que Kotlin, al igual que Java, maneja mediante “listeners” (escuchas): funciones, casi siempre lambdas, que se registran en un emisor para ser notificadas de lo que ocurre en él. Las interfaces gráficas de usuario (Swing, JavaFX, Compose) y los frameworks web se basan en este mecanismo: un clic en un botón o la llegada de una solicitud HTTP se notifica a los listeners registrados. Este curso no aborda las interfaces gráficas de usuario; todos los ejemplos son programas de consola.
Los programas de este capítulo están organizados en el proyecto Gradle [07-lambdas], con un paquete por programa: [src/main/kotlin/lambdas01/Lambdas01.kt], [src/main/kotlin/lambdas02/Lambdas02.kt]… Se ejecutan con [gradlew -q run -Pmain=lambdas01.Lambdas01Kt] o haciendo clic en el triángulo verde de IntelliJ o IDEA. El proyecto no requiere más bibliotecas que la biblioteca estándar de Kotlin: los tipos funcionales, las lambdas y las funciones de alcance están incluidos, y las interfaces del paquete [java.util.function] son las mismas que las del JDK.
7.1. Tipos funcionales e interfaces funcionales predefinidas
7.1.1. El concepto de tipo funcional
Un tipo funcional describe un modelo (también llamado firma o forma) de función: los tipos de sus parámetros, entre paréntesis, seguidos de una flecha y luego del tipo de su valor de retorno. Una variable de tipo funcional puede referirse a cualquier función de esta forma y ejecutarla. A continuación se muestran algunos ejemplos:
- [() -> Unit]: una función sin parámetros que no devuelve ningún resultado útil ([Unit] cumple el papel del [void] de Java);
- [() -> String]: una función sin parámetros que devuelve una cadena de caracteres;
- [(Int) -> Boolean]: una función que recibe un entero y devuelve un booleano, es decir, un predicado;
- [(Int, Int) -> Int]: una función que recibe dos enteros y devuelve un entero;
- [(String) -> (Int) -> Int]: una función que recibe una cadena y devuelve… una función de tipo [(Int) -> Int] (la flecha se lee de derecha a izquierda);
- [(() -> Unit)?]: una función que puede estar ausente; los paréntesis son necesarios porque [() -> Unit?] denotaría, de otro modo, una función que devuelve un [Unit?]. Aquí vemos la propiedad de seguridad frente a [null] del capítulo 3: una función de este tipo se invoca mediante [f?.invoke()];
- [String.(Int) -> String]: una función con receptor; se aplica a una cadena, que su código denota como [this], como una función de extensión (capítulo 4). Puede llamarse como extensión (["ab".f(3)]) o como una función ordinaria cuyo receptor es el primer parámetro ([f("ab", 3)]).
Los parámetros pueden nombrarse para documentar el tipo: [(n1: Int, n2: Int) -> Int] es el mismo tipo que [(Int, Int) -> Int].
Hay tres maneras de obtener un valor de tipo función:
- escribir una referencia a una función existente que tenga la forma correcta: [val task: () -> Unit = ::display];
- escribir una expresión lambda: [val task: () -> Unit = { println("task") }];
- escribir una función anónima: [val task = fun() { println("task") }], o un objeto de una clase que implemente el tipo funcional (un tipo funcional es una interfaz, como veremos). Estas dos notaciones son menos habituales.
La función se ejecuta entonces como una función ordinaria: [task()]. Es una notación abreviada para llamar al método [invoke] del objeto función: [task.invoke()]. Esta es la primera diferencia notable con Java, donde hay que llamar al método de la interfaz por su nombre ([run], [apply], [test]…); Kotlin se comporta aquí como C#, donde un delegado se llama como un método.
7.1.2. Tipos funcionales de Kotlin e interfaces de java.util.function
Antes de Java 8, cada biblioteca de Java definía sus propias interfaces de un solo método ([Runnable], [Comparator], [ActionListener]…). Java 8 introdujo el paquete [java.util.function], que proporciona 43 interfaces funcionales genéricas. Kotlin no las necesita: un tipo funcional se escribe directamente. Sin embargo, estas interfaces siguen pudiendo usarse desde Kotlin, y las encontrará cada vez que llame a una biblioteca de Java. La siguiente tabla relaciona las principales interfaces de Java con los tipos funcionales de Kotlin:
Interfaz de Java | Tipo de Kotlin | Funciones representadas |
[Runnable]: [void run()] | [() -> Unit] | Sin parámetros ni resultado |
[Supplier<T>] : [T get()] | [() -> T] | Sin parámetros, un resultado: un “proveedor” |
[Consumer<T>]: [void accept(T t)] | [(T) -> Unit] | Un parámetro, sin resultado: un “consumidor” |
[BiConsumer<T, U>] | [(T, U) -> Unit] | Dos parámetros, sin resultado |
[Function<T, R>]: [R apply(T t)] | [(T) -> R] | Un parámetro, un resultado |
[BiFunction<T, U, R>] | [(T, U) -> R] | Dos parámetros, un resultado |
[UnaryOperator<T>] | [(T) -> T] | Parámetro y resultado del mismo tipo |
[BinaryOperator<T>] | [(T, T) -> T] | Dos parámetros y un resultado del mismo tipo |
[Predicate<T>]: [boolean test(T t)] | [(T) -> Boolean] | Un parámetro, un resultado booleano: un “predicado” |
[BiPredicate<T, U>] | [(T, U) -> Boolean] | Dos parámetros, un resultado booleano |
[Comparator<T>]: [int compare(T o1, T o2)] | [(T, T) -> Int] | Dos parámetros del mismo tipo, un resultado entero |
[Callable<V>] : [V call()] | [() -> V] | como [Supplier<V>]; en Kotlin no es necesario declarar ninguna excepción verificada |
[IntBinaryOperator], [IntPredicate]… | [(Int, Int) -> Int], [(Int) -> Boolean]… | Las versiones de Java para tipos primitivos |
En Kotlin no hay un límite práctico para el número de parámetros de un tipo función: [(Int, Int, Int) -> Int] se escribe tan fácilmente como los demás, mientras que en Java, como no existe una interfaz predefinida con tres parámetros, hay que definir una propia.
¿Cómo representa la máquina virtual de Java, que solo reconoce clases e interfaces, un tipo funcional? Mediante interfaces genéricas de la biblioteca de Kotlin: [kotlin.jvm.functions.Function0<R>], [Function1<P1, R>], [Function2<P1, P2, R>]… hasta [Function22], y a partir de ahí una interfaz [FunctionN] . Cada una tiene un único método, [invoke]: [(Int, Int) -> Int] se compila en [Function2<Integer, Integer, Integer>], cuyo método es [operator fun invoke(p1: Int, p2: Int): Int]. Es el modificador [operator] de [invoke] (véase la sobrecarga de operadores en el capítulo 4) el que permite la notación [f(2, 3)]. Por lo tanto, un tipo funcional es, para la JVM, una interfaz funcional como las de Java. Dado que los genéricos de Java solo se aplican a tipos de objeto, los valores [Int] pasados a un [(Int, Int) -> Int] se convierten en [Integer] y viceversa (boxing y unboxing). Java evita estas conversiones con sus interfaces especializadas ([IntBinaryOperator]…); Kotlin las evita de otra manera, mediante las funciones [inline], de las que hablaremos más adelante.
El programa [Lambdas01.kt] utiliza estos tipos con referencias a funciones:
Resultados:
Comentarios:
- línea 11: la variable [task] es de tipo [() -> Unit]. Se le asigna una referencia a una función: [::display] hace referencia a la función de nivel superior [display] declarada más adelante en el archivo (línea 79). El compilador verifica que tenga la forma requerida (sin parámetros ni valor de retorno) y crea el objeto función que la llama. En Java habría hecho falta una clase auxiliar para contener estos métodos, ya que la clase implícita de un archivo fuente compacto no puede nombrarse; en Kotlin, las funciones de nivel superior se referencian directamente;
- línea 13: la función se ejecuta llamándola como una función ordinaria. Se ejecuta la función [display] (línea 1 de los resultados). Línea 15: se obtiene el mismo resultado llamando explícitamente al método [invoke] (línea 2 de los resultados);
- Línea 18: [(Int, Int) -> Int] hace referencia a una función con dos parámetros, [Int], que devuelve un [Int]. La función [add] (línea 83) es adecuada. La función se llama mediante [operation(2, 3)] (línea 19);
- línea 21: una función sin parámetros que devuelve una cadena, el equivalente del [Supplier<String>] de Java. Observe que la variable local [greet] tiene el mismo nombre que la función [greet]: en [::greet] se hace referencia a la función, y en [greet()] a la variable local, que oculta la función;
- Línea 25: una función con un parámetro, [String], que no devuelve nada, el equivalente del [Consumer<String>] de Java. La función de la biblioteca estándar [println] está sobrecargada ([println(Int)], [println(Any?)]…): es el tipo esperado, [(String) -> Unit], el que permite al compilador elegir la sobrecarga correcta;
- Línea 29: un predicado, equivalente a [Predicate<Integer>]. Línea 33: la función de extensión [removeAll] de la biblioteca de Kotlin espera específicamente un parámetro de tipo [(T) -> Boolean]: elimina de la lista mutable todos los elementos para los que el predicado se evalúa como [true], y devuelve [true] si ha eliminado al menos un elemento (línea 7 de los resultados);
- Línea 38: la función [sortWith] espera un [Comparator<T>]. En Kotlin, [Comparator] es un alias de la interfaz de Java [java.util.Comparator]. [Comparator(::compareLengths)] crea un [Comparator<String>] a partir de la función [compareLengths]: se trata de una conversión SAM (“Single Abstract Method”), que crea el objeto que implementa la interfaz de Java a partir de una función de Kotlin de la misma forma. La función [compareLengths] (línea 91) utiliza [compareTo], que compara dos objetos [Int] sin el riesgo de desbordamiento de capacidad (que una simple resta no garantiza);
- líneas 42–44: las interfaces de
*[java.util.function]pueden usarse tal cual. Se construyen de la misma manera, mediante una conversiónSAMexplícita: el nombre de la interfaz seguido de una referencia a una función o de una lambda. Luego se ejecutan mediante su método de Java ([get], [applyAsInt]*, [test]…), igual que en Java; - líneas 49–52: [removeIf] es un método de Java de la interfaz [Collection]; espera un [Predicate]. Se le puede pasar un
*[Predicate](línea 49), pero también directamente un valor de tipo*[(Int) -> Boolean](línea 51) o una lambda (línea 52): cuando se llama a un método de Java que espera una interfaz funcional, Kotlin realiza automáticamente la conversión SAM. Esto es lo que hace que las bibliotecas de Java sean tan agradables de usar desde Kotlin como desde Java. La lista inicial (10, 3, 8, 7, 2, 1) va perdiendo sucesivamente los elementos mayores que 4, los pares y luego el elemento 1 (línea 11 de los resultados); - líneas 56–57 y 72–75: a la función
*[execute]se le pasa una función que puede estar ausente, de tipo*[(() -> Unit)?]. La llamada segura [callback?.invoke()] no hace nada si [callback] es igual a [null]. No se puede escribir [callback?()]: la llamada segura a una función que admite valores nulos pasa por [invoke]. Esta será la notación estándar para los listeners opcionales; - Línea 60: un tipo funcional con receptor. La referencia [String::repeat] hace referencia al método [repeat] de la clase [String], que se aplica a una cadena y recibe un entero. La línea 61 se invoca de dos maneras: como extensión, ["ab".times(3)], o como una función con dos parámetros, [times("cd", 2)]. Volveremos a ver las funciones con receptor en las funciones de alcance [apply] y [with];
- líneas 64–68: una función es un objeto. La clase de la referencia a la función [operation] (línea 16 de la salida) es una clase generada por el compilador de Kotlin, que lleva el nombre del lugar donde aparece la referencia; la clase de la lambda [sum] (línea 18 de los resultados) la genera en tiempo de ejecución la máquina virtual, igual que las lambdas de Java: su nombre contiene [$$Lambda] seguido de una dirección que cambia de una ejecución a otra. En ambos casos, la clase implementa la interfaz [kotlin.jvm.functions.Function2] (líneas 17 y 19 de los resultados). Por lo tanto, una función de Kotlin no es un nuevo tipo de objeto: es una instancia de una clase ordinaria que implementa una interfaz funcional.
7.2. Definición de tipos funcionales propios
Los tipos funcionales suelen ser suficientes, pero puede interesar darle un nombre a un modelo de función. Kotlin ofrece dos herramientas para ello, de naturaleza muy diferente.
La primera es el alias de tipo, declarado con la palabra clave [typealias]:
- [typealias BinaryOperation = (n1: Int, n2: Int) -> Int]
Un alias no crea un tipo nuevo: [BinaryOperation] es otro nombre para [(Int, Int) -> Int], y las dos notaciones son intercambiables. El alias hace el código más legible cuando el tipo funcional es largo o aparece con frecuencia.
La segunda es la interfaz funcional, declarada mediante [fun interface]:
- [fun interface Operation { fun calculate(n1: Int, n2: Int): Int }]
Es el equivalente exacto de una interfaz funcional de Java: una interfaz con un solo método abstracto (también conocida como interfaz SAM, o “Single Abstract Method”). También puede tener métodos con cuerpo y propiedades no abstractas; estos no cuentan. La palabra clave [fun] que precede a [interface] cumple la misma función que la anotación de Java [@FunctionalInterface], con una diferencia importante: no es opcional. Es esta palabra clave la que habilita la conversión SAM, es decir, la creación de un objeto [Operation] a partir de una lambda o de una referencia a una función: [Operation { n1, n2 -> n1 + n2 }]. Sin la palabra clave [fun], una interfaz de Kotlin, incluso reducida a un solo método, solo puede ser implementada por una clase o un objeto anónimo ([object : Operation { … }]).
En comparación con el tipo [(Int, Int) -> Int], el tipo [Operation] es un tipo realmente nuevo, distinto de todos los demás: tiene un nombre que describe su propósito, su método tiene un nombre descriptivo ([calculate] en lugar de [invoke]), puede tener métodos adicionales y puede ser implementado por una clase con nombre. En contrapartida, se ejecuta mediante el nombre de su método ([op.calculate(2, 3)]), y no mediante [op(2, 3)].
Una variable llamada [op] de tipo [Operation], como una variable de tipo [(Int, Int) -> Int], hace referencia a una sola función a la vez. A diferencia de C#, que ofrece “delegados de multidifusión”, ni Java ni Kotlin permiten almacenar varias funciones en una sola variable y ejecutarlas todas con una sola llamada: cuando es necesario, se almacenan las funciones en una lista y se ejecutan una por una. Es exactamente lo que haremos con los listeners de eventos.
Consideremos el ejemplo [Lambdas02.kt]:
Resultados:
Comentarios:
- líneas 60–64: definición de la interfaz funcional [Operation]. En Kotlin, las declaraciones de tipos pueden colocarse en cualquier lugar del archivo, antes o después de la función [main]; nosotros las colocamos después;
- Línea 64: una interfaz funcional puede tener métodos con cuerpo (el equivalente de los métodos [default] de Java). El método [then] construye una nueva [Operation]: este objeto realiza la operación actual y luego aplica la función [next] a su resultado. Devuelve una lambda convertida en [Operation], que examinaremos en la sección siguiente. Observe que el parámetro [next] no requiere una interfaz como el [IntUnaryOperator] de la versión Java: el tipo funcional [(Int) -> Int] es suficiente, y se ejecuta mediante [next(…)];
- líneas 76–89: la clase [Calculations] tiene dos métodos de instancia, [add] y [subtract], y un método de su objeto complementario (companion object), [increase] (el equivalente de un método estático, véase el capítulo 4), los tres con la misma forma que el método [calculate];
- línea 9: la variable [op] es de tipo [Operation]. Se le asigna el objeto obtenido al convertir a SAM la referencia [Calculations::increase], que hace referencia al método [increase] del objeto complementario de la clase [Calculations]. La conversión debe escribirse así: [Operation(Calculations::increase)] se parece a una llamada a un constructor, pero una interfaz no tiene constructor; el compilador crea el objeto que implementa [Operation];
- línea 11: la operación la realiza el método [calculate] . Es el método [increase] el que se ejecuta, con los parámetros pasados a [calculate];
- Línea 15: se crea una instancia de la clase [Calculations] con el identificador [c1];
- Línea 17: la referencia [c1::add] hace referencia al método [add] del objeto [c1]: se denomina “referencia ligada” (bound reference). [increase] era un método del objeto complementario, mientras que [add] es un método de instancia: esto no supone ninguna diferencia. En el segundo caso, el objeto creado por el compilador almacena además el objeto [c1] sobre el que se llamará al método;
- línea 21: se hace lo mismo con el método de instancia [subtract];
- líneas 26–32: para ejecutar varias operaciones, se colocan en una lista de tipo [List<Operation>] (tipo inferido), que luego se recorre. Pueden mezclarse referencias y lambdas (línea 29). Se recupera cada resultado (líneas 7–11 de los resultados);
- línea 36: el método [then] se aplica a la operación [Operation(c1::add)]. La lambda [{ x -> x * x }] se pasa fuera de los paréntesis porque es el último (y en este caso el único) parámetro de [then]: explicaremos esta sintaxis con más detalle en la sección siguiente. [squaredSum.calculate(1, 2)] calcula (1+2)², es decir, 9 (líneas 12–13 de los resultados). En Java había que escribir explícitamente la conversión [((Operation) c1::add).then(…)]; en Kotlin, la conversión SAM explícita cumple este propósito;
- Línea 40: [Operation] y la interfaz de Java [IntBinaryOperator] tienen exactamente la misma forma, pero son dos tipos diferentes sin relación de herencia. La asignación [val other: IntBinaryOperator = op] sería rechazada ([initializer type mismatch: expected 'IntBinaryOperator', actual 'Operation']). En cambio, la referencia [op::calculate] es una función de tipo [(Int, Int) -> Int]: la conversión SAM la convierte en un [IntBinaryOperator], que llama al método [calculate] del objeto [op] ([c1::subtract] en esta etapa del programa);
- líneas 68–69: una interfaz funcional puede ser genérica. [Transformation<T, R>] representa una función que recibe un [T] y devuelve un [R]: es equivalente a [(T) -> R], con nombres elegidos por nosotros;
- Línea 44: [String::length] hace referencia a la propiedad [length] de la clase [String]: una referencia puede apuntar tanto a una propiedad como a una función. Se usa como una función de tipo [(String) -> Int]: la propiedad se leerá de la cadena pasada como parámetro. Los tipos [T = String] y [R = Int] de [Transformation] se infieren a partir de la referencia. Línea 45: ["*"::repeat] hace referencia al método [repeat(Int)] del objeto cadena ["*"]: recibe un entero y devuelve una cadena. Son dos tipos diferentes de referencias (no ligada y ligada), que veremos en detalle en la sección siguiente;
- línea 73: un alias de tipo. Los parámetros llamados [n1] y [n2] sirven únicamente para documentar;
- líneas 50–54: la lambda [f] de tipo [BinaryOperation] se asigna sin conversión a la variable [g] de tipo [(Int, Int) -> Int]: son el mismo tipo. Para convertirla en una [Operation], en cambio, se requiere una conversión SAM (línea 54).
Estas reglas pueden verificarse provocando errores. Si se escribe ***[var op: Operation = Calculations::increase]*** sin una conversión explícita, el compilador lo rechazará:
El mensaje también revela el tipo de una referencia a una función: [KFunction2<Int, Int, Int>], un tipo de reflexión de Kotlin ([kotlin.reflect]) que además es un [(Int, Int) -> Int]. La conversión SAM implícita solo se produce para los argumentos de una llamada a una función (por ejemplo, [values.removeIf(isEven)]), no para una asignación.
Si se agrega por error un segundo método abstracto, como [fun invert(n: Int): Int], a la interfaz [Operation], el compilador señala la propia declaración y cada una de las conversiones SAM que usan la interfaz (salida abreviada):
Estos mensajes provienen del compilador [kotlinc]; Gradle los muestra precedidos de [e:] y de la ruta completa del archivo. Al igual que los de [javac], están en inglés.
7.3. Objetos anónimos, expresiones lambda y referencias
7.3.1. De los objetos anónimos a las lambdas
En los ejemplos anteriores, cada función es una función con nombre definida en otra parte del programa. Para funciones cortas que se usan una sola vez, esto resulta engorroso. Java ofrecía originalmente la clase anónima: la clase que implementa la interfaz se define justo donde se crea el objeto. Kotlin tiene un equivalente, la expresión de objeto [object : Type { … }], presentada en el capítulo 4, pero rara vez la usa para representar una función: desde el principio, Kotlin admite las expresiones lambda, que ofrecen una sintaxis mucho más concisa. El programa [Lambdas03.kt] muestra las diferentes formas:
Resultados:
Comentarios:
- líneas 7–12: un objeto anónimo. La palabra clave [object] va seguida de dos puntos y del tipo que se va a implementar, en este caso el tipo funcional [(Int, Int) -> Int] (es una interfaz, como hemos visto), y del cuerpo de una clase que implementa este tipo redefiniendo su método [invoke]. El compilador genera una clase sin nombre y crea una instancia de ella. Seis líneas para expresar [n1 + n2]. Aun así, se ejecuta como una función: [add(2, 3)];
- línea 15: lo mismo con una expresión lambda. Una lambda se escribe entre llaves: la lista de parámetros, el operador [->] (una flecha, que se lee “da”), y luego el cuerpo. El nombre del tipo y el nombre del método han desaparecido. Como los parámetros tienen tipo, el compilador puede determinar por sí solo el tipo de la lambda: [(Int, Int) -> Int]. Esto difiere de Java, donde una lambda nunca tiene un tipo propio;
- línea 19: se han omitido los tipos de los parámetros. El compilador los infiere a partir del tipo esperado declarado para la variable: [n1] y [n2] son de tipo [Int]. Esta es la forma más común. En Kotlin no hay distinción entre un “cuerpo de expresión” y un “cuerpo de bloque”, como ocurre en Java: el cuerpo de una lambda es una secuencia de instrucciones, y el valor de la última expresión es el resultado de la lambda;
- Línea 23: con un solo parámetro, no es necesario declararlo, ni tampoco la flecha; entonces se llama implícitamente [it] (“it”, “eso”). [{ it * it }] se lee “su cuadrado”. Línea 24: el único parámetro se llama [s]. Esto se hace cuando [it] haría el código menos legible, en particular cuando las lambdas están anidadas (cada una tendría su propio [it]);
- Líneas 28–29: sin parámetros, no hay flecha. El tipo de
*[greet]*se infiere como*[() -> String]*; el tipo de*[beep]es*[() -> Unit]*, ya que*[println]produce*[Unit]*; - Líneas 34–39: una lambda puede contener cualquier instrucción: declaraciones, bucles, condicionales, etc. El valor de la última expresión, [buffer.toString()], es el resultado. No se puede escribir [return buffer.toString()]: en una lambda, un [return] sin etiqueta no sale de la lambda (véase más adelante);
- línea 44: el carácter de subrayado [_] denota un parámetro no utilizado. Se usa cuando la firma del tipo exige parámetros que la lambda no necesita, lo cual es habitual en los listeners de eventos. Se pueden incluir varios de estos parámetros en la misma lambda (Java adoptó esta sintaxis en la versión 22);
- Líneas 48–49: el uso más común de las lambdas es pasarlas directamente como parámetros a una función de orden superior. Cuando la lambda es el último parámetro, se escribe fuera de los paréntesis; si no hay otros parámetros, se omiten los paréntesis: [numbers.filter { it % 2 == 0 }] en lugar de [numbers.filter({ it % 2 == 0 })]. Esta regla es la que da al código Kotlin su aspecto característico y permite escribir funciones que se parecen a instrucciones del lenguaje ([repeat], [use], [thread], [synchronized]…). Compárese con [Lambdas01.kt]: ya no es necesario escribir una función [isEven];
- línea 51: una lambda que invierte la comparación habitual: la lista se ordena de forma descendente. [sortWith] espera un [Comparator] (una interfaz de Java): la conversión a SAM se realiza automáticamente;
- línea 54: la lambda permanece fuera de los paréntesis cuando la función tiene otros parámetros: [fold(0) { acc, n -> acc + n }]. La función [fold] (capítulo 5) parte del valor inicial 0 y suma los elementos uno por uno;
- líneas 58–62: dentro de una lambda, la instrucción [return@forEach] sale de la lambda (y pasa así al elemento siguiente), igual que un [continue] en un bucle. La etiqueta [@forEach] es implícita: es el nombre de la función a la que se pasa la lambda. Un [return] sin etiqueta saldría de toda la función [main]: esto se denomina retorno no local, y solo se permite en una lambda pasada a una función como [inline] o [forEach] (veremos por qué);
- líneas 64–68: también puede elegirse la etiqueta colocándola antes de la llave de apertura: [odd@{ … }], luego [return@odd];
- líneas 70–74: una función anónima. Se escribe como una función normal, pero sin nombre. Su tipo se infiere: [(Int) -> Boolean]. En una función anónima, [return] sale de la propia función anónima. Se usa cuando el cuerpo tiene varios puntos de salida, o cuando se desea especificar explícitamente el tipo del resultado;
- Línea 78: los parámetros de una lambda pueden desestructurarse (capítulo 3). La lambda pasada a [forEach] recibe una entrada del arreglo asociativo ([Map.Entry<String, Int>]); la notación [(name, age)], entre paréntesis, la descompone en su clave y su valor. Atención: [{ name, age -> … }] declararía dos parámetros, mientras que [{ (name, age) -> … }] declararía un único parámetro desestructurado.
Repasemos las formas de una expresión lambda:
Forma | Ejemplo |
Parámetros con tipo | [{ a: Int, b: Int -> a + b }] |
Parámetros sin tipo (tipo esperado conocido) | [{ a, b -> a + b }] |
Un único parámetro, implícito | [{ it * it }] |
Sin parámetros | [{ "Hello" }] |
Parámetros no utilizados | [{ _, _ -> println("received") }] |
Parámetro desestructurado | [{ (key, value) -> "$key=$value" }] |
Varias instrucciones | [{ x -> println(x) ; x * 2 }] |
Lambda como último parámetro | [list.filter { it > 0 }] |
Función anónima | [fun(x: Int): Int { return x * 2 }] |
Una lambda no es exactamente una abreviatura de un objeto anónimo. En un objeto anónimo, [this] hace referencia al propio objeto anónimo; en una lambda, [this] hace referencia al objeto del método que contiene la lambda (o al receptor, en el caso de una lambda con receptor). Además, un objeto anónimo puede implementar una interfaz con varios métodos, varias interfaces a la vez, o heredar de una clase, lo cual es imposible con una lambda. En este curso utilizaremos lambdas siempre que sea posible.
7.3.2. Información adicional: inferencia de tipos y referencias
El programa [Lambdas04.kt] explica cómo se determina el tipo de una lambda y describe los diferentes tipos de referencias:
Resultados:
Comentarios:
- línea 11: la lambda [{ x: Int -> x * 2 }] tiene su propio tipo, [(Int) -> Int], calculado a partir del tipo de su parámetro y del de su cuerpo. La declaración [val double = { x -> x * 2 }], en cambio, es rechazada: el compilador no puede inferir el tipo de [x] ([an explicit type is required on a value parameter]). En Java, [var twice = x -> x * 2;] se rechaza por una razón más fundamental: una lambda de Java no puede existir sin un tipo de destino, que especifica la interfaz que se va a implementar;
- líneas 14–16: la misma expresión lambda, [{ "Hello" }], produce aquí un [() -> String], allí un [Supplier<String>] y en otro lugar un [Callable<String>]. En los dos últimos casos, es el nombre de la interfaz de Java, colocado antes de la lambda, el que desencadena la conversión a SAM. Se trata de tres objetos de clases diferentes, que solo comparten la forma de su método;
- líneas 19–41: los tipos de referencias. Kotlin las denomina “referencias invocables” (callable references): hacen referencia a funciones, pero también a propiedades y constructores:
- línea 21: la referencia a una función de nivel superior, [::function]. [::triple] equivale a la lambda [{ n -> triple(n) }]. Sustituye a la referencia a un método estático en Java ([Class::staticMethod]). Para una función de un objeto complementario, se escribe [Class::function], como en [Lambdas02.kt];
- líneas 25–26: la referencia a un método o propiedad de un objeto dado, [object::method], denominada referencia ligada. [name::uppercase] equivale a [{ name.uppercase() }]: el objeto [name] queda fijado de una vez por todas. [name::length] hace referencia a la propiedad [length] de la cadena [name];
- Líneas 30–31: una referencia a un método de cualquier objeto de una clase, [Class::method], conocida como referencia no ligada. El objeto sobre el que se llamará al método aún no se conoce: se convierte en el primer parámetro de la función. [String::uppercase] equivale a [{ s: String -> s.uppercase() }]. Para [ignoreCase], se prefirió una lambda, lo que permite pasar el argumento con nombre [ignoreCase = true] a [compareTo];
- línea 35: una función de extensión se referencia como un método: [String::toInt] equivale a [{ s: String -> s.toInt() }];
- Líneas 38–41: la referencia a un constructor, [::Class] (en Java: [Class::new]). [::ArrayList] equivale a [{ ArrayList() }]; [::StringBuilder], con el tipo esperado [(String) -> StringBuilder], selecciona el constructor que recibe una cadena; [::IntArray] crea un arreglo de enteros del tamaño pasado como parámetro; [::Person] hace referencia al constructor primario de la clase de datos [Person] (línea 65);
- línea 44: se usan las funciones de creación; [reverse] invierte el contenido del [StringBuilder] (línea 8 de los resultados);
- Líneas 47–51: Kotlin no admite excepciones verificadas (capítulo 3). Por lo tanto, una lambda de tipo [() -> Int] puede lanzar una [IOException] sin declarar nada. En Java, esto era un verdadero problema: ninguna interfaz de [java.util.function] permite excepciones verificadas, y se rechaza una lambda de tipo [Supplier<Integer>] que lance una [IOException] ; por eso había que usar [Callable], cuyo método se declara como [throws Exception]. Observe también que la lambda [{ throw IOException("file missing") }] se acepta como un [() -> Int]: la expresión [throw] es de tipo [Nothing], que es compatible con todos los tipos;
- líneas 55–59: dos evaluaciones de la misma referencia
***[name::uppercase]producen dos objetos diferentes ([r1 === r2]es igual a*[false]*), pero, a diferencia de Java, Kotlin los considera *iguales en el sentido de [equals] ([r1 == r2] es igual a [true]): dos referencias son iguales si hacen referencia a la misma función, asociada al mismo objeto. Dos lambdas, incluso con texto idéntico, nunca son iguales (línea 10 de los resultados). Tenga esto presente: será importante al cancelar el registro de un listener de eventos. Por último, observe que se debió escribir el tipo de*[r1]: la función [uppercase] está sobrecargada ([uppercase()] y [uppercase(locale: Locale)]), y sin un tipo esperado, el compilador se niega a elegir ([overload resolution ambiguity between candidates]*).
Una referencia es simplemente una notación abreviada para una lambda que se limita a llamar a una función. Se usa cuando mejora la legibilidad: [String::length] en lugar de [{ it.length }]. En la práctica, con [it], las lambdas de Kotlin son tan cortas que las referencias se usan algo menos que en Java.
7.3.3. Composición de funciones
Las interfaces funcionales de Java tienen métodos [default] y [static] que crean nuevas funciones a partir de otras existentes: [andThen], [compose], [and], [or], [negate]… Los tipos funcionales de Kotlin no los tienen: la biblioteca estándar no proporciona una función [andThen] para un [(A) -> B]. Pero es muy fácil escribirlas uno mismo, como funciones de extensión sobre tipos funcionales (capítulo 4), ya que una función puede devolver una función. El programa [Lambdas05.kt] lo demuestra y luego presenta las funciones de la biblioteca de Kotlin que construyen comparadores:
Resultados:
Comentarios:
- Línea 60: la función de extensión [then] se aplica a una función de tipo [(A) -> B] (los paréntesis alrededor del tipo función son obligatorios) y recibe una función [next] de tipo [(B) -> C]. Devuelve una nueva función de tipo [(A) -> C], la lambda [{ x -> next(this(x)) }], que aplica primero la función [this] (el receptor de la extensión) y luego [next] a su resultado. Este es el método [andThen] de la interfaz de Java [Function]. Los tres parámetros de tipo [A], [B] y [C] son genéricos: [then] compone cualquier función de un solo parámetro, siempre que el resultado de la primera sea adecuado para la segunda. El modificador [infix] permite escribir [f then g] en lugar de [f.then(g)];
- línea 63: la composición inversa, equivalente al método de Java [compose]: [f after g] aplica primero [g] y luego [f];
- línea 11: [plusOne then timesTwo] devuelve la función que aplica primero [plusOne] y luego [timesTwo] al resultado: (5 + 1) × 2 = 12. Los paréntesis alrededor de la composición son necesarios para poder llamar a la función resultante;
- Línea 12: [plusOne after timesTwo] aplica primero [timesTwo] y luego [plusOne]: 5 × 2 + 1 = 11;
- línea 14: si se prefieren los métodos de la interfaz de Java, basta con crear una [Function] mediante una conversión SAM: [andThen] queda entonces disponible, y se le puede pasar una lambda de Kotlin, que a su vez se convierte. El resultado es una
*[Function], que se ejecuta mediante*[apply]; - líneas 17–18 y 76: [adder] es una función que devuelve una función: [adder(10)] devuelve la función que suma 10 a su parámetro. La función devuelta puede almacenarse en una variable ([plusTen]) o llamarse de inmediato: [adder(3)(5)]. Este procedimiento, que consiste en fijar un parámetro para obtener una función de los parámetros restantes, se denomina aplicación parcial;
- líneas 20–21: una cadena de procesamiento construida dinámicamente. Se parte de la función identidad ([{ s: String -> s }], que devuelve su parámetro sin cambios) y, con [then], se le agrega cada paso de la lista, gracias a la función [fold] (capítulo 5): el valor acumulado, [function], es aquí una función. La función resultante [normalize] elimina los espacios iniciales y finales ([trim]), convierte el texto a minúsculas y reemplaza los espacios por guiones. Cada llamada a [then] crea una función nueva: las funciones existentes nunca se modifican. Del mismo modo, la lista de pasos podría leerse desde un archivo de configuración;
- Líneas 66–70: los predicados se combinan con nuestras extensiones [and], [or], y [not]. Esta última se declara como [operator]: es la función que llama el operador [!] (véase la sobrecarga de operadores en el capítulo 4). Así, [!short] se escribe para la negación del predicado [short] (línea 30). En Java se escribe [isShort.negate()], y [Predicate.not(String::isEmpty)] para una referencia a un método;
- líneas 32–33: un predicado de tipo [(CharSequence) -> Boolean] es aceptado por [filterElements] para filtrar una lista de [String], aunque el parámetro está declarado como [(T) -> Boolean] con [T = String]. Esto se debe a que los tipos funcionales de Kotlin son contravariantes en sus parámetros y covariantes en sus resultados (capítulo 4): [(T) -> R] es en realidad [Function1<in T, out R>]. Una función que puede procesar cualquier [CharSequence] también puede procesar un [String]. En Java, hay que declarar el parámetro como [Predicate<? super T>] para lograr este resultado; en Kotlin, ocurre automáticamente;
- líneas 36–42 y 73: la extensión [andAlso] devuelve una función que realiza dos operaciones sucesivas sobre el mismo valor, como el método [andThen] de la interfaz de Java [Consumer]. Es la forma más sencilla de ejecutar varias operaciones con una sola llamada. Observe que la lambda [{ this(it); other(it) }] tiene dos instrucciones en la misma línea, separadas por un punto y coma;
- línea 47: la función [compareBy(f)] de la biblioteca de Kotlin construye un comparador que compara los valores de [f] (aquí, la edad); [thenBy] especifica el criterio de desempate que se usará en caso de empate (aquí, el nombre). Son los equivalentes de [Comparator.comparing] y [thenComparing] en Java. Las referencias [Person::age] y [Person::name] hacen referencia a las propiedades de la clase de datos [Person] (líneas 89–90), para la cual hemos redefinido el método [toString] a fin de acortar la salida;
- línea 49: [reversed] invierte el orden obtenido hasta ese momento, y [thenByDescending] agrega un criterio en orden descendente;
- línea 52: [compareBy] también acepta varios criterios, en forma de expresiones lambda, que se aplican en orden: aquí, la longitud del nombre y luego el nombre. Son dos lambdas pasadas como argumentos, ya que [compareBy] las recibe en un parámetro de tipo [vararg];
- líneas 55–56: la función [minOf] devuelve el menor de sus dos primeros parámetros según el comparador pasado como tercer parámetro (en Java: [BinaryOperator.minBy]);
- líneas 79–86: la función [filterElements] utilizada para estas pruebas. Es una función de orden superior que hace lo mismo que la función de la biblioteca [filter]: aplica el predicado [predicate] a cada elemento (llamándolo como una función ordinaria) y conserva los elementos para los que devuelve [true].
Estas funciones permiten escribir procesamientos complejos combinando funciones simples, sin escribir una sola clase. Volveremos sobre ellas al tratar las colecciones y las secuencias.
7.3.4. Captura de variables y clausuras
Una lambda puede usar las variables locales de la función en la que está escrita. Se dice que captura estas variables. En este aspecto, Kotlin difiere significativamente de Java. Java exige que una variable local capturada sea “efectivamente final”: que nunca se modifique después de su inicialización, ni en el método ni en la lambda. Kotlin, como C#, JavaScript o Python, no impone tal restricción: una lambda puede capturar una variable [var], leerla incluso después de que haya cambiado, e incluso modificarla. El programa [Lambdas06.kt] muestra lo que permite esta libertad, cómo se implementa y la trampa que conlleva:
Resultados:
Comentarios:
- Línea 11: la lambda utiliza la variable local [threshold] declarada en la línea 10. [threshold] no es un parámetro de la lambda; es una variable capturada. Como es un [val], la lambda recibe simplemente una copia de su valor cuando se crea, exactamente como en Java;
- líneas 15–19: esta vez, la lambda captura un
*[var]*, que Java rechazaría (*[local variables referenced from a lambda expression must be final or effectively final]). No recibe una copia del valor, sino que comparte la variable con la función [main]: cuando [variableThreshold] cambia a 10 (línea 19), la misma lambda devuelve un resultado diferente (líneas 2–3 de los resultados). Por lo tanto, la función lambda ve el valor de la variable en el momento en que se ejecuta*, no en el momento en que se creó. Este es el problema que Java evita al prohibir estas capturas; - Líneas 23–27: la lambda [accumulate] modifica la variable local [total]. En Java hay que usar un objeto mutable ([AtomicInteger], o el recurso de un arreglo de un solo elemento); en Kotlin se escribe directamente [total += n];
- línea 29: ¿cómo es posible esto, si la propia máquina virtual solo permite capturar valores? El compilador de Kotlin hace el trabajo que un desarrollador Java debe hacer manualmente: una variable local [var] capturada y modificada ya no se almacena en la pila, sino en un pequeño objeto de la clase [kotlin.jvm.internal.Ref.IntRef] (hay una por cada tipo primitivo, y
*[Ref.ObjectRef]para las referencias), que tiene un único campo mutable,*[element]. La función [main] y la lambda comparten este objeto: cada lectura o escritura de [total], en cualquiera de las dos, se convierte en una lectura o escritura de [total.element]. Podemos verificarlo mediante reflexión: el único campo del objeto lambda es de tipo [Ref$IntRef] (línea 5 de los resultados). Esto es exactamente lo que hace el compilador de C# con sus variables capturadas; - líneas 31–34: una lambda también puede leer y modificar una variable de nivel superior (línea 6) o una propiedad del objeto actual. Aquí no hay nada que capturar: la variable de nivel superior es un campo estático de la clase [Lambdas06Kt]; en el caso de una propiedad, la lambda captura la referencia [this];
- líneas 64–67: la función [createCounter] devuelve una lambda que captura y modifica su variable local [value]. Normalmente, una variable local desaparece cuando termina la función. Aquí, la variable se almacena en un objeto [Ref.IntRef] referenciado por la lambda: sobrevive a [createCounter] mientras exista la lambda. La combinación de la lambda y las variables que captura se denomina una “clausura” (closure);
- líneas 37–40: cada llamada a
*[createCounter]crea una nueva variable[value]*, y por lo tanto un nuevo contador, independiente de los demás. Los resultados (líneas 7–8) lo confirman; - líneas 44–48: en un bucle [for] de Kotlin, la variable [i] es un [val], nuevo en cada iteración: cada lambda captura el suyo, y las tres lambdas muestran 0, 1 y 2. Observe que una lista de funciones se ejecuta mediante [actions.forEach { it() }]: [it] es una función que se llama;
- Líneas 53–59: este es el inconveniente de la flexibilidad de Kotlin. El bucle [while] utiliza una sola variable, [k], que se modifica en cada iteración. Las tres lambdas capturan la misma variable y muestran su valor cuando se ejecutan, es decir, después del bucle, cuando es igual a 3: todas muestran 3 (línea 10 de los resultados). Java elimina esta trampa en tiempo de compilación; en Kotlin, le corresponde al desarrollador manejarla. La solución es la misma que en Java: declarar un nuevo [val] en el cuerpo del bucle para cada iteración ([val copy = k]) y capturarlo, o, mejor aún, usar un bucle [for].
La regla de Java tiene una justificación sólida: una lambda puede ejecutarse más tarde, o en otro hilo (capítulo 8). Si puede modificar las variables locales de una función, o leerlas mientras otro hilo las modifica, esto puede provocar un comportamiento impredecible. Kotlin adopta un enfoque diferente y más práctico: capturar [var] está permitido, pero los objetos [Ref] no están protegidos contra el acceso concurrente. Por lo tanto, recordemos que capturar un [var] es seguro en un programa de un solo hilo y en lambdas que se ejecutan de inmediato ([forEach], [filter]…), pero que, en cuanto una lambda puede ejecutarse en otro hilo, el estado mutable compartido debe hacerse explícito mediante un objeto cuyo comportamiento respecto de los hilos se elija explícitamente ([AtomicInteger], colección concurrente…). Volveremos sobre este tema en los capítulos 8 y 9. Las funciones [inline], que se presentan más adelante, también evitan la creación de objetos [Ref] cuando el código de la lambda se copia en el código que llama.
7.4. Funciones inline y funciones de alcance
7.4.1. Funciones inline
Una lambda es un objeto. Por lo tanto, pasar una lambda a una función de orden superior tiene un costo: la creación del objeto (excepto en el caso de una lambda que no captura nada, que la máquina virtual puede reutilizar), la llamada a su método [invoke] , las conversiones [Int] ↔ [Integer] impuestas por las interfaces genéricas [Function1], [Function2]…, y los objetos [Ref] de las variables capturadas. Para una función como [filter], que se llama sobre cada elemento de colecciones que a veces pueden ser muy grandes, este costo importa. Kotlin lo elimina con el modificador [inline]: cuando una función se declara [inline fun], el compilador no genera una llamada a esa función; en su lugar, copia su código en cada lugar donde se la llama, y copia también el código de las lambdas que se le pasan. Como resultado, ya no hay objetos lambda, ni llamadas a [invoke], ni conversiones. Las funciones de la biblioteca estándar que aceptan lambdas ([forEach], [filter], [map], [fold], [let], [apply], [repeat], [use], [synchronized]…) son casi todas [inline]. Java no tiene un equivalente: confía en el compilador just-in-time de la máquina virtual para producir un resultado comparable en tiempo de ejecución.
La inserción del código tiene una segunda consecuencia, más notoria: como el código de la lambda se copia en la función que llama, una instrucción [return] sin etiqueta puede salir desde allí de la función que llama. Este es el retorno no local que encontramos con *[forEach] en *[Lambdas03.kt]. Dos modificadores complementan a *[inline]*:
- [noinline], aplicado a un parámetro de función de una función [inline], especifica que la lambda correspondiente no debe copiarse, sino pasarse como un objeto normal. Esto es necesario cuando la función quiere conservar la lambda (almacenarla en una lista, devolverla como resultado, etc.): el código copiado no se puede almacenar en una lista;
- [crossinline] exige que la lambda se copie, pero prohíbe los retornos no locales. Esto es necesario cuando la función [inline] no ejecuta la lambda por sí misma, sino en otro contexto, por ejemplo, dentro de un objeto [Runnable] que ella crea: cuando [Runnable] se ejecuta, la función que llama puede haber terminado hace mucho tiempo, y un [return] ya no podría salir de ella.
El programa [Lambdas07.kt] ilustra estos conceptos (este programa no tiene equivalente en el curso de Java):
Resultados:
Comentarios:
- Línea 28: la función [currentMethod] devuelve el nombre del método que la llamó. Para ello, crea un objeto [Throwable], que guarda la pila de ejecución en el momento de su creación, y lee el segundo elemento de esa pila (el primero es [currentMethod] mismo). Lo usamos para determinar dónde se ejecuta el código de una lambda;
- líneas 31–36: dos funciones idénticas, una ordinaria y la otra declarada como [inline];
- línea 7: la lambda se pasa a la función ordinaria [execute]. El compilador la convierte en el cuerpo de un método privado de la clase [Lambdas07Kt], llamado [main$lambda$0] en este caso, y crea un objeto de tipo [() -> Unit] que lo llama. Efectivamente, es [main$lambda$0] el que se ejecuta (línea 1 de los resultados);
- línea 8: la lambda se pasa a la función [inline] [executeInline]. El compilador copió el cuerpo de [executeInline] y el de la lambda en [main]: el [println] de la lambda se ejecuta directamente dentro del método [main] (línea 2 de los resultados). No se creó ningún objeto función;
- líneas 41–50: [forEachElement] es nuestra propia versión de [forEach], [inline], igual que el original. En [firstEven], la instrucción [return it] de la lambda es un retorno no local: sale de la [firstEven] función devolviendo el primer número par encontrado (línea 3 de los resultados), y el bucle se detiene allí. Con una función ordinaria como [execute], el compilador rechazaría tal [return] (['return' is prohibited here]): la lambda sería un objeto independiente, que podría ejecutarse después de que [firstEven] haya terminado;
- líneas 54–60: una función [inline] que recibe dos lambdas: ejecuta la primera y almacena la segunda en una lista para ejecutarla más tarde. El segundo parámetro debe declararse como [noinline]: sin este modificador, el compilador se niega a almacenar la lambda en la lista ([illegal usage of inline parameter 'stored: () -> Unit'. Add 'noinline' modifier to the parameter declaration.]). Las líneas 16–18 la utilizan (líneas 4–6 de la salida);
- línea 64: la función [asTask] crea un objeto [Runnable] (conversión SAM) que ejecutará la lambda [action]. El parámetro debe declararse como [crossinline]: sin este modificador, el compilador lo rechaza ([cannot inline 'action: () -> Unit' here: it might contain non-local returns. Add 'crossinline' modifier to parameter declaration 'action: () -> Unit'.]). Las líneas 21–24 ejecutan el [Runnable] obtenido en un hilo llamado [worker] (los hilos se tratan en el capítulo 8), como lo confirma la línea 7 de los resultados.
No debe usarse [inline] en cualquier función: el modificador solo es útil para funciones que aceptan parámetros funcionales, y aumenta el tamaño del código generado (de hecho, el compilador emite una advertencia para una función [inline] sin parámetros funcionales). Por último, tiene un tercer uso, tratado en el capítulo 4: solo las funciones [inline] pueden tener parámetros de tipo [reified] ([inline fun <reified T> …]), cuyo tipo sigue siendo conocido en tiempo de ejecución, ya que el código se copia en el lugar donde ese tipo es conocido.
7.4.2. Funciones de alcance
La biblioteca estándar de Kotlin proporciona cinco funciones pequeñas y muy utilizadas, [inline], conocidas como “funciones de alcance” (scope functions): [let], [run], [with], [apply] y [also]. Casi no hacen nada: cada una ejecuta una lambda sobre un objeto. Se diferencian en dos aspectos:
- la forma en que la lambda hace referencia al objeto: ya sea como su parámetro [it] (la lambda es de tipo [(T) -> R]), o como su receptor [this], que entonces puede omitirse (la lambda es una lambda con receptor, de tipo [T.() -> R]; véase [Lambdas01.kt]);
- que es lo que devuelve la función: o bien el resultado de la lambda, o bien el propio objeto.
Función | Objeto designado por | Devuelve | Uso típico |
[let] | [it] | el resultado de la lambda | transformar un valor; con [?.let], procesar un valor no nulo |
[run] | [this] | el resultado de la lambda | Calcular un resultado a partir de las propiedades del objeto |
[with(object)] | [this] | el resultado de la lambda | como [run], donde el objeto se pasa como parámetro |
[apply] | [this] | el objeto | Configurar un objeto recién creado |
[also] | [it] | el objeto | Procesamiento adicional (registro, caché, etc.) sin modificar la cadena de llamadas |
El programa [Lambdas08.kt] las utiliza (no tiene equivalente en el curso de Java):
Resultados:
Comentarios:
- líneas 45–48: una clase [Person] normal con propiedades mutables;
- líneas 7–9: [apply] ejecuta la lambda con el objeto como receptor: dentro de la lambda, [age = 32] equivale a [this.age = 32]. Luego devuelve el objeto, que se asigna a [paul]. Así se crea y configura un objeto en una sola expresión. Su firma ilustra el mecanismo: [inline fun <T> T.apply(block: T.() -> Unit): T];
- línea 15: [also] ejecuta la lambda con el objeto como parámetro [it] y luego devuelve el objeto. Se utiliza para obtener un efecto secundario (en este caso, agregar a una lista) sin tener que introducir una variable intermedia;
- línea 19: [let] ejecuta la lambda con el objeto como parámetro [it] y devuelve el resultado de la lambda: se trata de una transformación;
- Líneas 21–23: El uso más común de [let], como se vio en el capítulo 3: [city?.let { … }] ejecuta la lambda solo si [city] no es [null]y, dentro de la lambda, [it] es de tipo [String] y no [String?]. Si [city] es igual a [null], la expresión es igual a [null], y el operador Elvis [?:] proporciona el valor predeterminado;
- Línea 27: [run] ejecuta la lambda con el objeto como receptor y devuelve el resultado de la lambda: utiliza directamente las propiedades [name], [age] y [city] de [paul];
- Líneas 31–34: [with] hace lo mismo que [run], pero el objeto se le pasa como primer parámetro y la lambda va en segundo lugar, fuera de los paréntesis. Todos los métodos llamados dentro de la lambda ([append], [toString]) son los de [StringBuilder]. La función [buildString] del capítulo 5 se basa en este modelo;
- líneas 39–41: [takeIf] no es una función de ámbito, pero se usa de la misma manera: devuelve el objeto si cumple el predicado y [null] en caso contrario. Se combina de forma natural con [?:], [?.let]… ([takeUnless] hace lo contrario).
Estas funciones hacen el código más compacto, pero no deben usarse en exceso: varias funciones de ámbito anidadas, cada una con su propio [it] o [this], vuelven rápidamente el código ilegible. A menudo es preferible una variable local con un buen nombre.
7.5. ¿Tipos funcionales, interfaces funcionales o interfaces?
En muchos lenguajes, el concepto de “función pasada como parámetro” (puntero a función en C, delegado en C#) es distinto del concepto de interfaz, y uno puede preguntarse cuál elegir. En Java, la cuestión se plantea de otro modo, ya que los dos conceptos son uno solo: una lambda es una instancia de una interfaz. Kotlin se sitúa en un punto intermedio: tiene tipos funcionales, que se distinguen de las interfaces por la sintaxis pero son interfaces para la máquina virtual; y tiene interfaces funcionales ([fun interface]) que se pueden implementar mediante lambdas. Tomemos el ejemplo [Lambdas09.kt], que es similar a [Lambdas02.kt]:
Resultados:
En la línea 18, la función [execute] espera un parámetro de tipo [(Int, Int) -> Int]. Esto permite pasarle funciones distintas: nuestras funciones de alto nivel [add] y [subtract] (líneas 7 y 9), un método de la biblioteca de Java con la forma correcta (línea 11: entre las sobrecargas de [Math.max]*, el compilador elige [int max(int a, int b)]***, que Kotlin ve como ***[max(a: Int, b: Int): Int]***), e incluso una lambda (línea 13): no fue necesario escribir una función de multiplicación. El parámetro de función se colocó al final** para que la lambda pudiera escribirse fuera de los paréntesis: esta es la convención en toda la biblioteca de Kotlin y conviene seguirla en las funciones propias.
Con [fun interface], vemos el polimorfismo de interfaces tratado en el capítulo 4: el programa [Lambdas10.kt] lo demuestra implementando la misma interfaz con clases:
Resultados:
Comentarios:
- líneas 31–32: la interfaz funcional [Operation] define un método [calculate];
- líneas 41–49: las clases [Add] y [Subtract] implementan la interfaz [Operation];
- línea 25: la función [execute], cuyo primer parámetro es del tipo definido por la interfaz [Operation]. Recibe sucesivamente una instancia de la clase [Add], una instancia de la clase [Subtract] (líneas 7 y 9) y luego una lambda (línea 11). Para la lambda, la conversión de
SAMa*[Operation]se realiza automáticamente, ya que es un argumento de la llamada. Para [execute], estos tres objetos son del mismo tipo: objetos que implementan [Operation]*; - Líneas 36–37: la interfaz [NamedOperation] hereda el método [calculate] y agrega una propiedad abstracta [name]. No es funcional (de hecho, no puede declararse como
[fun interface]): ya no se puede implementar mediante una lambda; se necesita una clase, en este caso un objeto anónimo (líneas 13–16); - líneas 57–58: lo inverso también es cierto: una clase puede implementar un tipo funcional, ya que es una interfaz. Sus instancias se llaman entonces como funciones ([modulo(7, 2)]) y se pasan donde se espera una función ([applyFunction(modulo, 7, 3)], línea 21).
Estos dos ejemplos muestran que en Kotlin, al igual que en Java, una función que espera un comportamiento acepta objetos de clases escritas para ese fin, referencias y lambdas. Quedan dos preguntas. La primera es específica de Kotlin: para un parámetro funcional, ¿es obligatorio un tipo funcional o basta con una [fun interface]?
- El tipo funcional es la opción predeterminada. No requiere declaración, se llama como una función, acepta directamente lambdas y referencias, y se beneficia de las funciones [inline]. Un [typealias] le da un nombre cuando es largo;
- la interfaz “fun” se justifica cuando se desea un tipo verdaderamente distinto (que no pueda confundirse con otra función de la misma forma), un método con un nombre descriptivo, métodos adicionales con cuerpo, o una API destinada también a quienes llaman desde Java: para Java, una [fun interface] es una interfaz funcional ordinaria, utilizable con sus lambdas, mientras que un tipo funcional de Kotlin se le presenta como una [Function2<Integer, Integer, Integer>] cuyo método [invoke] debe devolver un objeto ([Unit] para una función “sin retorno”).
La segunda pregunta es la misma que en Java: ¿la interfaz debe tener un solo método o varios?
- Una función, un tipo funcional o una interfaz de un solo método es más flexible de usar: sirve cualquier función existente con la forma correcta, y una lambda permite incluso escribir la función justo donde se llama. No hay que escribir ninguna clase. Esta flexibilidad explica por qué las bibliotecas modernas (colecciones, las corrutinas del capítulo 9, Spring) usan ampliamente parámetros funcionales;
- una interfaz con varios miembros recupera la ventaja en cuanto el comportamiento que se debe implementar involucra varias operaciones relacionadas entre sí ([calculate] y [name] más arriba), o cuando requiere su propio estado e identidad.
Es el caso de la interfaz [ITaxDao] en la capa [dao] del capítulo 6: aunque solo tiene un miembro (la propiedad [val taxBrackets: List<TaxBracket>]), sus implementaciones tienen estado (los tramos leídos, el nombre del archivo), las crea el contenedor de inyección de dependencias y representan un rol claramente nombrado dentro de la aplicación. Un [() -> List<TaxBracket>] habría bastado técnicamente, pero habría sido mucho menos descriptivo. Por lo tanto, reservamos los tipos funcionales para comportamientos breves y puntuales (un criterio, una transformación, una acción), y las interfaces “de negocio” para los roles de la aplicación, sin importar el número de sus miembros.
7.6. Manejo de eventos
7.6.1. El patrón Observador
Las funciones pasadas como parámetros se utilizan para implementar eventos. Al igual que Java, Kotlin no tiene una palabra clave dedicada a los eventos (C# tiene la suya, [event]): utiliza las convenciones establecidas por Java desde la versión 1.1 para los componentes gráficos y los JavaBeans, conocidas como el “modelo de escuchas”. Una clase [C1] que quiere señalar un evento [Xxx] procede de la siguiente manera:
- Una clase [XxxEvent] encapsula la información sobre el evento, incluido el objeto que lo desencadenó, conocido como la fuente. En Java, la convención es que derive de [java.util.EventObject], que almacena la fuente; en Kotlin basta con una clase normal con propiedades de solo lectura, y eso es lo que haremos;
- Un tipo de escucha define la forma de la función que se llamará cuando ocurra el evento. En Java, es una interfaz llamada [XxxListener]; en Kotlin, suele ser un simple tipo funcional, [(XxxEvent) -> Unit], nombrado mediante un [typealias]: una escucha será una lambda o una referencia a función;
- la clase [C1] administra una lista de funciones y ofrece dos métodos públicos para registrarse y darse de baja en ella: [addXxxListener(listener)] y [removeXxxListener(listener)];
- Cuando una instancia [c1] de [C1] quiere señalar el evento, crea un objeto [XxxEvent] y llama a cada una de las escuchas registradas, pasándoles este objeto. Por convención, esta notificación la gestiona un método protegido [fireXxx(e: XxxEvent)] (“disparar”), que una clase derivada puede sobrescribir para modificar la forma en que se publica el evento;
- Si un objeto [c2] quiere ser notificado del evento [Xxx] del objeto [c1], se suscribe mediante [c1.addXxxListener(...)]. Puede darse de baja con [c1.removeXxxListener(...)] cuando ya no desea ser notificado. Dado que [c1] administra una lista, distintos objetos pueden suscribirse para ser notificados del mismo evento.
En este escenario, tenemos:
- una clase que señala (también se dice “publica” o “emite”) un evento;
- objetos que son notificados de este evento. Se dice que se suscriben o se registran al evento: son las escuchas, o manejadores de eventos;
- un tipo de escucha que define la forma de las funciones que serán notificadas del evento.
Este es el patrón de diseño Observador: el emisor no conoce a sus suscriptores; simplemente los notifica. Este modelo ofrece la misma protección que una palabra clave dedicada: la lista de escuchas es una propiedad privada del emisor. Desde el exterior, solo se puede suscribir o darse de baja; no se puede vaciar la lista, reemplazar otras escuchas ni disparar el evento en lugar del emisor.
7.6.2. Un ejemplo: temperatura excesivamente alta
Consideremos el siguiente ejemplo:
- Una clase llamada [Emitter] encapsula una temperatura. Cuando esta temperatura supera cierto umbral, debe dispararse un evento. Llamaremos a este evento [TemperatureTooHigh]. La información sobre este evento se encapsulará en un objeto [TemperatureTooHighEvent], y las escuchas serán funciones de tipo [TemperatureTooHighListener];
- una clase llamada [Subscriber] se registra como escucha del evento anterior. Cuando se le notifica el evento, muestra un mensaje en la consola. Una escucha se da de baja automáticamente tras recibir un número determinado de alertas;
- Un programa de consola crea un emisor y dos suscriptores. Ingresa temperaturas por el teclado y las registra en el emisor. Si alguna es demasiado alta, el emisor señala el evento [TemperatureTooHigh].
Este programa se divide en tres archivos del paquete [lambdas11]. Primero está el archivo [Emitter.kt], que contiene la clase del evento, el tipo de escucha y la clase [Emitter]:
Comentarios:
- Líneas 7–14: la clase [TemperatureTooHighEvent] almacena la fuente del evento, de tipo [Emitter], y la temperatura que lo desencadenó. Agregamos la hora del evento, [time], que se inicializa al crear el objeto. Todas las propiedades son de tipo [val]: una escucha no debe poder modificar la información del evento para las escuchas siguientes. No derivamos la clase de [EventObject] como en Java: no serviría de nada aquí y nos obligaría, para que la fuente sea de tipo [Emitter] en lugar de [Any], a redefinir el método [getSource];
- Línea 18: el tipo de la escucha. Una escucha es una función que recibe el objeto del evento como argumento y no devuelve nada. Mientras que Java exige una interfaz
*[TemperatureTooHighListener]* derivada de*[EventListener]*, Kotlin simplemente usa un alias de tipo funcional. Podríamos haber declarado igualmente una***[fun interface TemperatureTooHighListener]***: sería la elección correcta si las escuchas se fueran a escribir en Java; - línea 24: el umbral de temperatura por encima del cual se dispara el evento [TemperatureTooHigh], una constante del objeto complementario;
- línea 21: el emisor tiene un nombre para su identificación. La clase se declara como [open], para que una clase derivada pueda redefinir el método [fireTemperatureTooHigh];
- línea 28: la lista de escuchas registradas, una lista de funciones. Es una [CopyOnWriteArrayList] del paquete [java.util.concurrent], una lista que, cada vez que se modifica, copia su contenido en un nuevo arreglo. Por lo tanto, una iteración en curso continúa sobre el arreglo anterior, aunque la lista se modifique entretanto. Más adelante veremos por qué esto es esencial aquí. Esta lista es el tipo estándar para listas de escuchas: la lista se recorre en cada evento, pero rara vez se modifica;
- Líneas 31–36: la propiedad [temperature] tiene un descriptor de acceso [set] personalizado (capítulo 4): almacena el nuevo valor en el campo oculto [field] y luego señala el evento si supera el umbral. La publicación está a cargo del método [fireTemperatureTooHigh], al que se le pasa un objeto [TemperatureTooHighEvent]; este objeto proviene del propio emisor ([this]) y contiene la temperatura que superó el umbral. Mientras que Java exige un método llamado [setTemperature], quien usa la clase simplemente escribe [e1.temperature = 21.0];
- líneas 41–42: registrar una escucha la agrega a la lista. El tipo del parámetro no admite nulos: el compilador rechaza cualquier escucha de tipo [null], algo que Java debe rechazar en tiempo de ejecución mediante [Objects.requireNonNull];
- líneas 46–47: darse de baja elimina la escucha de la lista. El método [remove] busca el objeto que se va a eliminar mediante [equals]: por lo tanto, hay que pasarle un objeto idéntico al que se registró;
- líneas 51–53: la notificación llama a cada escucha registrada, en el orden en que se registraron, como una función: [listener(e)]. Si no hay escuchas, el bucle no hace nada: no hay casos especiales que manejar.
Este es el archivo [Subscriber.kt]:
Comentarios:
- líneas 4–11: cada suscriptor se identifica por un nombre y se le asigna el número máximo de alertas que acepta ([nbMaxAlerts]). Cuenta las alertas recibidas ([nbAlerts]);
- líneas 14–15: registro ante un emisor. La escucha es una referencia enlazada, [::onTemperatureTooHigh], es decir, [this::onTemperatureTooHigh]: el método de este suscriptor, [onTemperatureTooHigh];
- líneas 19–20: darse de baja pasa una nueva referencia, [::onTemperatureTooHigh], a [removeTemperatureTooHighListener]. En Java, este sería un error clásico: dos evaluaciones de
[this::onTemperatureTooHigh]producen dos objetos que[equals]*considera distintos, y la baja no eliminaría nada, sin ningún mensaje de error; la escucha debe crearse una sola vez y almacenarse en un campo. Vimos con [Lambdas04.kt] que en Kotlin dos referencias a la misma función del mismo objeto son iguales: [remove] encuentra por lo tanto la escucha registrada, y solo esa, ya que las referencias de los demás suscriptores están enlazadas a otros objetos. No sucedería lo mismo con una lambda: [{ e -> onTemperatureTooHigh(e) }]*, escrita dos veces, daría como resultado dos objetos distintos; - Línea 24: el manejador del evento. Tiene la forma dictada por el tipo [TemperatureTooHighListener]. Es privado: solo el suscriptor puede registrarlo ante un emisor. Otro enfoque consiste en que la propia clase [Subscriber] implemente el tipo de escucha ([class Subscriber : TemperatureTooHighListener], con un método [invoke]) y se registre con [this]. Este enfoque tiene el inconveniente de hacer público el método [invoke], que cualquiera podría entonces llamar;
- línea 25: la fuente del evento es directamente de tipo [Emitter];
- líneas 26–28: el manejador muestra el nombre del suscriptor, el nombre del emisor que informó del evento y la temperatura que lo desencadenó. El formato [%.1f] muestra el número real con un decimal, según las convenciones locales de la máquina (la función [format] de Kotlin las utiliza; aquí, un punto decimal). La cadena se escribe en dos partes concatenadas mediante [+] para que la línea quepa en la página;
- líneas 30–33: tras [nbMaxAlerts] alertas, el suscriptor se da de baja del emisor. Lo hace durante la notificación del evento, desde su propio manejador; es decir, mientras el método [fireTemperatureTooHigh] recorre la lista de escuchas. Esto es seguro gracias a [CopyOnWriteArrayList]: [remove] crea un nuevo arreglo, pero la iteración en curso continúa sobre el anterior.
Por último, aquí está el programa principal, [Lambdas11.kt]:
Resultados (la entrada estándar se proporcionó mediante redirección; hemos reinsertado las entradas después de los avisos, en los puntos donde el programa las lee):
Comentarios:
- línea 7: creación del emisor;
- líneas 9–11: creación de dos suscriptores, [s0] (hasta 3 alertas) y [s1] (1 alerta), que se registran en el emisor;
- líneas 14–15: una tercera escucha, una lambda pasada fuera de los paréntesis, que actúa como registro. El tipo del parámetro [e] se infiere del tipo del parámetro de [addTemperatureTooHighListener]. El formato [%tT] muestra una hora con la forma [HH:mm:ss]. Esta lambda no se puede dar de baja: habría que haberla almacenado en una variable para pasar el mismo objeto a [removeTemperatureTooHighListener]. Por lo tanto, las lambdas escritas directamente en la llamada de registro se reservan para las escuchas que permanecen registradas mientras exista el emisor;
- líneas 19–33: bucle para ingresar temperaturas por el teclado. [readlnOrNull()] lee una línea; devuelve [null] si la entrada estándar está cerrada, un caso que se trata como una entrada vacía mediante [isNullOrBlank] (línea 23). Después de esta prueba, el compilador sabe que [input] no es [null] (conversión inteligente de tipos);
- línea 27: [toDoubleOrNull] acepta solo el punto decimal. Para permitir que un usuario francés escriba [22,5], la coma se reemplaza por un punto. Si la entrada no es un número, [toDoubleOrNull] devuelve [null]: no hace falta capturar una excepción como hace la versión de Java con [Double.parseDouble];
- Línea 33: si la temperatura ingresada es correcta, se asigna a la propiedad [temperature] del emisor [e1], cuyo descriptor de acceso [set] señala el evento [TemperatureTooHigh] si es mayor que 19 °C.
Los resultados muestran (las horas varían de una ejecución a otra):
- línea 1: 17 °C no supera el umbral: no hay evento;
- líneas 2–6: 21 °C dispara el evento. Las tres escuchas son notificadas en el orden en que se registraron. [s1], que acepta una sola alerta, se da de baja de inmediato, pero eso no impide que se notifique al registro, que se registró después;
- líneas 9–11: [s1] ya no es notificado: la baja mediante una nueva referencia funcionó como se esperaba;
- líneas 12–15: [s0] recibe su tercera alerta y se da de baja a su vez;
- líneas 16–17: solo queda el registro.
¿Qué pasaría si hubiera simplemente una [ArrayList] en lugar de la [CopyOnWriteArrayList] en la clase [Emitter]? Lo probamos: cuando [s1] se da de baja mientras se procesa la lista, se omiten los elementos siguientes y el procesamiento se detiene de inmediato. El registro no es notificado de las temperaturas 21 y 25, sin ningún mensaje de error. En otras configuraciones, el bucle lanza una [ConcurrentModificationException]. Por lo tanto, una lista de escuchas debe admitir siempre cambios mientras se la recorre: la [CopyOnWriteArrayList] está diseñada para este fin, y también admite suscripciones y bajas hechas por otros hilos (capítulo 8).
7.6.3. Eventos de cambio de propiedad
El tipo de evento más común se produce cuando una propiedad de un objeto cambia de valor: otro objeto (una interfaz gráfica de usuario, una caché, un registro) quiere ser notificado de este cambio. Kotlin y la biblioteca de Java ofrecen dos herramientas complementarias para este escenario:
- las propiedades delegadas de Kotlin. Una propiedad declarada como [var p: T by delegate] delega la lectura y la escritura de su valor en otro objeto, el delegado. La biblioteca estándar proporciona varios, como [by lazy { … }], que calcula el valor de la propiedad en el primer acceso. El objeto [kotlin.properties.Delegates] proporciona dos delegados que aceptan una lambda: [Delegates.observable(initialValue) { property, old, new -> … }] ejecuta la lambda después de cada escritura en la propiedad; [Delegates.vetoable(initialValue) { property, old, new -> … }] la ejecuta antes y acepta el nuevo valor solo si la lambda devuelve [true]. El parámetro [property] es una referencia a la propiedad ([KProperty]), cuyo nombre se obtiene mediante [property.name];
- la clase de Java [java.beans.PropertyChangeSupport], que administra por nosotros la lista de escuchas. Las escuchas implementan la interfaz funcional [PropertyChangeListener], cuyo método [void propertyChange(PropertyChangeEvent evt)] recibe un evento que contiene la fuente, el nombre de la propiedad y sus valores anterior y nuevo.
El delegado [observable] sabe cuándo cambia una propiedad, y [PropertyChangeSupport] sabe a quién notificar: el programa [Lambdas12.kt] los vincula:
Resultados:
Comentarios:
- Líneas 3–4: el paquete [java.beans] pertenece al módulo [java.desktop] del JDK, no al módulo [java.base]. Como nuestro programa no es un módulo de Java, todas las clases del JDK son accesibles para él: basta con importarlas;
- Línea 45: la clase [Thermometer] delega la administración de sus escuchas en un objeto [PropertyChangeSupport], construido con la fuente del evento ([this]). Los métodos de las líneas 60–69 le transmiten simplemente las suscripciones y bajas, y la propiedad [nbListeners] (líneas 72–73) devuelve el número de escuchas registradas;
- líneas 48–50: una pequeña función genérica que crea un delegado [Delegates.observable] cuya lambda pasa cada cambio a [firePropertyChange], junto con el nombre de la propiedad ([property.name]), el valor anterior y el nuevo valor. Devuelve un
*[ReadWriteProperty<Any?, T>]*, la interfaz de los delegados de propiedades mutables. Como un método, una lambda escrita dentro de una clase puede acceder a las propiedades privadas del objeto, en este caso[changes]; - líneas 53–54: las dos propiedades observables de la clase. La palabra clave [by] delega su administración en un delegado creado por nuestra función [observable]. En comparación con la versión de Java, donde cada setter debe almacenar el valor anterior, guardar el nuevo y llamar a
*[firePropertyChange]con el nombre de la propiedad escrito como cadena, la versión de Kotlin cabe en una sola línea por propiedad, y el nombre de la propiedad no puede escribirse mal. El delegado ejecuta la lambda en cada escritura, incluso si el valor no cambia; sin embargo, [firePropertyChange]* solo notifica a las escuchas si los dos valores son distintos: la escritura de la línea 28, que no cambia el valor, no produce por lo tanto ninguna salida; - líneas 13–17: un primer observador, una lambda convertida a [PropertyChangeListener] y almacenada en una variable para poder darla de baja (línea 31). Está suscrita a todas las propiedades del objeto. [e.source] (es decir, [e.getSource()], visto desde Kotlin como una propiedad) es de tipo [Any], que debe convertirse a [as]. Los valores son objetos: los objetos [Double] se muestran mediante su método [toString], que usa el punto decimal;
- Líneas 19–21: una segunda escucha, registrada únicamente para la propiedad [temperature]. La lambda se mueve fuera de los paréntesis y se convierte a [PropertyChangeListener] (conversión SAM). Dispara una alerta cuando la temperatura supera los 19 °C. [e.newValue as Double] convierte el nuevo valor, de tipo [Any?], a Double;
- Líneas 25–33: los cambios de propiedad se realizan mediante simples asignaciones. El cambio de nombre (línea 29) solo se notifica al registro. En la línea 4 de los resultados, el registro muestra el nuevo nombre de la fuente, [lounge]: el evento se notifica después del cambio. Tras darse de baja del registro, solo se muestra la alerta, y queda una sola escucha;
- línea 57: la propiedad [setpoint] usa el delegado [vetoable]. Su lambda, llamada antes de cada operación de escritura, acepta el nuevo valor solo si está entre 5 y 30 °C ([new in 5.0..30.0]); sus dos primeros parámetros, que aquí no son necesarios, se denotan con [_]. Líneas 36–38: el valor 21 se acepta, mientras que el valor 45 se rechaza; la propiedad conserva su valor anterior (líneas 7–8 de los resultados). Las instancias de JavaBeans tienen un mecanismo equivalente, con [VetoableChangeSupport] y escuchas que lanzan una [PropertyVetoException].
Sin escribir una clase de evento ni un tipo de escucha, obtenemos así un mecanismo completo. [PropertyChangeSupport] es el que utilizan los componentes de interfaz gráfica Swing y JavaBeans; JavaFX tiene su propio mecanismo, muy similar, para las propiedades observables. Los delegados [observable] y [vetoable], en cambio, bastan por sí solos cuando hay un único observador, conocido en el momento de escribir la clase. Por último, cabe señalar que, para los flujos de eventos asíncronos, Kotlin ofrece el [Flow] de la biblioteca kotlinx.coroutines, que veremos en el capítulo 9 ([StateFlow], en particular, actúa como una propiedad observable).
7.7. Lambdas, colecciones y secuencias
En el capítulo 5 usamos las operaciones funcionales de las colecciones ([filter], [map], [sortedBy]…) y de las secuencias pasándoles lambdas. Ahora sabemos qué son estos parámetros: la función [filter] se declara así en la biblioteca estándar: [inline fun <T> Iterable<T>.filter(predicate: (T) -> Boolean): List<T>].
Es una función de extensión, [inline], cuyo parámetro es un tipo funcional: sirve cualquier función o lambda que reciba un elemento y devuelva un Boolean. De manera similar, [map] espera un [(T) -> R], [sortedBy] espera un [(T) -> R?], y [R] es comparable, [forEach] corresponde a un [(T) -> Unit], [reduce] a un [(S, T) -> S]… Para entender a fondo cómo funcionan, escribamos nuestras propias operaciones de filtrado y transformación. Este es el programa [Lambdas13.kt]:
Resultados:
Comentarios:
- Líneas 9–11: las lambdas de [filter] y de [map] se asignan primero a variables para revelar sus tipos. [map] transforma cada elemento: se obtienen así los cuadrados de los números pares;
- línea 13: el mismo cálculo con el stream de la API de Java, que puede usarse tal cual desde Kotlin: el método de Java [filter] espera un [Predicate], [map] espera una [Function], y las lambdas de Kotlin se convierten automáticamente (conversión SAM). Rara vez se usa en Kotlin para cálculos secuenciales, ya que las funciones de colecciones y secuencias son más sencillas; sigue siendo útil para los streams paralelos del capítulo 8, o cuando una biblioteca de Java devuelve un [Stream];
- Líneas 51–58: nuestra función [filterBy], escrita como función de extensión de [List<T>] y declarada como [inline], igual que [filter]. Es genérica: filtra una lista de elementos de cualquier tipo [T]. Recorre la lista ([this]), llama al predicado con cada elemento (línea 54) y devuelve la lista de los elementos seleccionados;
- Línea 16: llamada a [filterBy] con una lambda, fuera de los paréntesis. El tipo [T] se infiere de la lista: [Int]. En la línea 17, se le pasa una referencia a función: [isOdd] (línea 61) tiene la forma [(Int) -> Boolean];
- Líneas 20–25: un predicado detallado, que muestra cada elemento que prueba, aplicado a una lista. Las operaciones de colecciones son inmediatas: [filter] prueba todos los elementos y construye la lista de resultados completa antes de devolverla (líneas 5–6 de los resultados). En una cadena [list.filter { … }.map { … }], cada paso crea por lo tanto una lista intermedia;
- líneas 29–34: el mismo predicado aplicado a una secuencia ([asSequence()]). El resultado (líneas 7–8) muestra que la definición de la secuencia no ejecuta nada: el mensaje de la línea 33 se muestra antes de la primera prueba. Solo cuando la operación terminal [forEach] solicita los elementos se ejecuta el predicado, y las pruebas se alternan con las salidas de [forEach]: cada elemento recorre toda la cadena antes de que entre el siguiente. Esta es la ejecución diferida (o perezosa) de las secuencias, igual que la de los streams de Java. Las operaciones intermedias de las secuencias no son [inline]: deben conservar las lambdas para ejecutarlas más tarde;
- líneas 64–73: para escribir nuestras propias operaciones intermedias, que son perezosas como las de la biblioteca, usamos el constructor de secuencias [sequence]. Recibe una lambda en la que la función [yield] produce un elemento de la secuencia: por cada elemento solicitado desde el consumidor, la lambda reanuda su ejecución donde se quedó, hasta el siguiente [yield] (se trata de una corrutina, un concepto que estudiaremos en el capítulo 9). La etiqueta
[this@keep]designa al receptor de la función de extensión[keep], es decir, la secuencia original: sin etiqueta, [this] designaría al receptor de la lambda en [sequence], ya que esa lambda es una lambda con receptor. La función [keep] deja pasar únicamente los elementos que cumplen el predicado; la función [transform], que es doblemente genérica ([T] es el tipo de los elementos recibidos, [R] es el tipo de los elementos producidos), devuelve el resultado de la función aplicada a cada elemento. Java 24 introdujo los colectores intermedios ([Gatherer]) con el mismo propósito, que tienen una sintaxis considerablemente más compleja; - líneas 39–42: nuestras funciones de extensión se encadenan igual que las operaciones de la biblioteca: conservamos las ciudades de como máximo 5 letras y luego las convertimos a mayúsculas. La operación terminal [toList] desencadena el cálculo;
- líneas 45–47: [generateSequence(1) { it * 2 }] define una secuencia infinita: 1, seguido de cada elemento obtenido duplicando el anterior. Solo es utilizable gracias a la evaluación perezosa: [take(5)] solicita únicamente los cinco primeros elementos, y solo esos se calculan. La lambda pasada a [transform] muestra cada potencia con la forma [2^n=value] ([countTrailingZeroBits] cuenta los ceros más a la derecha en la representación binaria, es decir, el exponente).
Todas las operaciones sobre colecciones y secuencias se construyen sobre este modelo: funciones de orden superior que reciben tipos funcionales. En las colecciones, estas funciones son [inline] e inmediatas; en las secuencias, conservan las lambdas y calculan los elementos solo cuando los solicita la operación terminal.
7.8. Árboles de expresión
Algunos lenguajes, como C#, permiten convertir una lambda no en código ejecutable, sino en una estructura de datos que la describe (un “árbol de expresión”): un programa puede entonces analizar la lambda [t => t.Limit > 20000] y traducirla, por ejemplo, a una cláusula SQL [WHERE limits > 20000] ejecutada por el servidor de base de datos.
Kotlin, como Java, no tiene un equivalente: una lambda de Kotlin siempre se compila en código ejecutable; se puede llamar, pero no se puede examinar su funcionamiento interno. Sin embargo, varias herramientas se acercan:
- Las referencias a propiedades: [Person::age] es un objeto ([KProperty1<Person, Int>]) que conoce el nombre de la propiedad ([Person::age.name]) y su tipo. Una biblioteca puede aprovechar esto para construir una consulta sin escribir una cadena: eso es lo que hace Spring Data MongoDB, por ejemplo, con sus extensiones de Kotlin, que permiten escribir un criterio como [Person::age gt 18];
- Los DSL internos (“lenguajes específicos de dominio”): gracias a las lambdas con receptor, a las funciones [infix] y a la sobrecarga de operadores, una biblioteca de Kotlin puede ofrecer una sintaxis similar a SQL, que el programa ejecuta para construir una estructura de datos que describe la consulta. Este es el principio de la biblioteca Exposed, de JetBrains: [Brackets.selectAll().where { Brackets.limit greater 20000 }];
- los complementos del compilador: el compilador de Kotlin puede extenderse con complementos que transforman el código. Así funciona kotlinx.serialization, los complementos [all-open] y [no-arg] utilizados con Spring y Hibernate, o el complemento [power-assert], que analiza la expresión de una aserción para mostrar sus detalles en caso de fallo. Sin embargo, se trata de herramientas de desarrollo, no de características integradas del programa.
Hibernate, que veremos en el capítulo 11, ofrece las mismas soluciones que en Java: un lenguaje de consulta similar a SQL pero expresado en términos de clases y propiedades, HQL (["from Bracket t where t.limit > 20000"]), y la API Criteria de Jakarta Persistence, que construye la consulta mediante llamadas a métodos ([cb.gt(t.get("limit"), 20000)]). En ambos casos, la consulta son datos (una cadena o un árbol de objetos) que Hibernate traduce a SQL, mientras que una lambda pasada a [filter] se ejecuta dentro del programa Kotlin.
7.9. Conclusión
Puntos clave de este capítulo:
- En Kotlin, las funciones son valores: tienen un tipo funcional ([(Int, Int) -> Int], [() -> Unit], [(T) -> Boolean], [(() -> Unit)?], [T.() -> R]…), pueden almacenarse en variables, pasarse como parámetros, devolverse como resultados y llamarse como funciones ordinarias. Para la máquina virtual, son objetos que implementan las interfaces [Function0], [Function1]…;
- las interfaces de [java.util.function] ([Function], [Supplier], [Consumer], [Predicate]…), junto con [Runnable], [Callable] y [Comparator], siguen siendo utilizables: cuando un método de Java espera una interfaz funcional, Kotlin convierte automáticamente una lambda o una referencia a ella (conversión SAM); en otros casos, la conversión se escribe de forma explícita: [Comparator { … }];
- para nombrar un tipo de función, disponemos del alias [typealias] (simplemente un alias) y de [fun interface] (un verdadero tipo nuevo, implementable mediante una lambda);
- una función puede obtenerse mediante una expresión lambda ([{ a, b -> a + b }], [{ it * it }], escrita fuera de los paréntesis cuando es el último parámetro, y cerrada con [return@label]), mediante una función anónima, mediante un objeto anónimo, o mediante una referencia ([::function], [object::method], [Class::method], [::Class]). Dos referencias a la misma función del mismo objeto son iguales; dos lambdas nunca lo son;
- las lambdas capturan las variables que las rodean, incluidas las [var], que pueden modificar (el compilador las almacena en objetos [Ref]); entonces ven el valor de la variable en el momento de su ejecución, lo que exige precaución en los bucles y entre hilos;
- las funciones que devuelven funciones y las extensiones sobre tipos funcionales ([then], [and], [or]…) componen nuevas funciones; [compareBy], [thenBy] y [reversed] construyen comparadores;
- las funciones [inline] copian su código y el de las lambdas en el sitio de la llamada, sin objeto ni conversión, y permiten retornos no locales; [noinline] y [crossinline] tratan casos especiales. Las funciones de ámbito [let], [run], [with], [apply] y [also] son las aplicaciones más comunes de esto;
- se elige un tipo funcional para comportamientos breves y puntuales; una [fun interface] para un tipo distinto o una API que pueda usarse desde Java; una interfaz con varios miembros (o una interfaz “de negocio”) para un rol de la aplicación;
- un evento se implementa mediante el patrón de escuchas: una clase [XxxEvent], un tipo de escucha (a menudo un [typealias] de tipo funcional), [addXxxListener] / [removeXxxListener], y una lista de funciones ([CopyOnWriteArrayList]) recorrida por un método [fireXxx]. Las propiedades delegadas [Delegates.observable] y [Delegates.vetoable] señalan o filtran los cambios de una propiedad, y [PropertyChangeSupport] administra por ellas la lista de escuchas;
- las operaciones de colecciones (inmediatas, [inline]) y las operaciones de secuencias (perezosas) son funciones de orden superior; Kotlin no tiene árboles de expresión, e Hibernate expresa sus consultas mediante HQL o la API Criteria.
Las lambdas reaparecerán en todos los capítulos siguientes: un hilo ejecuta una lambda ([thread { … }]), y un [ExecutorService] ejecuta un [Callable] (capítulo 8); una corrutina se lanza con [launch { … }] o [async { … }] (capítulo 9), las funciones de extensión de [ResultSet] recibirán, en forma de lambda, la transformación de una fila del resultado en un objeto (capítulo 10), y los servicios web de Spring Boot procesan las solicitudes HTTP en métodos que el framework llama como escuchas (capítulo 13).