Skip to content

7. Tipos funcionais, lambdas e eventos

Em muitos programas, precisamos passar a uma função não dados, mas um comportamento: o critério de ordenação, a condição de filtragem ou a ação a executar quando algo acontece. O Kotlin atende a essa necessidade tratando as funções como valores, como quaisquer outros: uma função tem um tipo — o tipo funcional, denotado, por exemplo, como [(Int, Int) -> Int]; ela pode ser armazenada em uma variável, passada como parâmetro, retornada como resultado de outra função e executada quando se desejar. Uma função que recebe ou retorna uma função é chamada de função de ordem superior.

O Java, vale lembrar, não tem tipos funcionais: ele se baseia em interfaces funcionais — interfaces com um único método abstrato ([Runnable], [Comparator], [Function<T, R>]…) — e somente a partir do Java 8 (2014) passou a permitir implementá-las por meio de expressões lambda e referências a métodos. O Kotlin oferece suporte a lambdas desde sua primeira versão e também pode trabalhar com as interfaces funcionais do Java, já que usa diretamente as bibliotecas Java. Já usamos lambdas extensivamente, sem entrar em detalhes, nas operações sobre coleções vistas no Capítulo 5: em [persons.filter { it.age >= 18 }], passamos um lambda para a função [filter]. Este capítulo explica o que há por trás dessa sintaxe. Ele termina com os eventos, que o Kotlin — assim como o Java — trata por meio de “listeners”: funções, na maioria das vezes lambdas, que se registram em um emissor para serem notificadas do que acontece nele. As interfaces gráficas (Swing, JavaFX, Compose) e os frameworks web se baseiam nesse mecanismo: o clique em um botão ou a chegada de uma requisição HTTP é sinalizado aos listeners registrados. Este curso não aborda interfaces gráficas; todos os exemplos são programas de console.

Os programas deste capítulo estão organizados no projeto Gradle [07-lambdas], com um pacote por programa: [src/main/kotlin/lambdas01/Lambdas01.kt], [src/main/kotlin/lambdas02/Lambdas02.kt]… Eles são executados com [gradlew -q run -Pmain=lambdas01.Lambdas01Kt] ou clicando no triângulo verde no IntelliJ ou no IDEA. O projeto não requer nenhuma biblioteca além da biblioteca padrão do Kotlin: tipos funcionais, lambdas e funções de escopo já estão incluídos, e as interfaces do pacote [java.util.function] são as mesmas do JDK.

7.1. Tipos funcionais e interfaces funcionais predefinidas

7.1.1. O conceito de tipo funcional

Um tipo funcional descreve um modelo (também chamado de assinatura ou forma) de função: os tipos de seus parâmetros, entre parênteses, seguidos de uma seta e, depois, do tipo de seu valor de retorno. Uma variável de tipo funcional pode referenciar qualquer função dessa forma e executá-la. Eis alguns exemplos:

  • [() -> Unit]: uma função sem parâmetros que não retorna nenhum resultado útil ([Unit] faz o papel do [void] do Java);
  • [() -> String]: uma função sem parâmetros que retorna uma string;
  • [(Int) -> Boolean]: uma função que recebe um inteiro e retorna um booleano, ou seja, um predicado;
  • [(Int, Int) -> Int]: uma função que recebe dois inteiros e retorna um inteiro;
  • [(String) -> (Int) -> Int]: uma função que recebe uma string e retorna… uma função do tipo [(Int) -> Int] (a seta é lida da direita para a esquerda);
  • [(() -> Unit)?]: uma função que pode estar ausente; os parênteses são necessários porque [() -> Unit?] denotaria, caso contrário, uma função que retorna um [Unit?]. Vemos aqui a propriedade de segurança em relação a [null] vista no Capítulo 3: tal função é invocada por meio de [f?.invoke()];
  • [String.(Int) -> String]: uma função com receptor; ela é aplicada a uma string — que seu código denota como [this] — como uma função de extensão (Capítulo 4). Pode ser chamada como extensão (["ab".f(3)]) ou como uma função comum cujo receptor é o primeiro parâmetro ([f("ab", 3)]).

Os parâmetros podem receber nomes para documentar o tipo: [(n1: Int, n2: Int) -> Int] é o mesmo tipo que [(Int, Int) -> Int].

Há três maneiras de obter um valor de um tipo funcional:

  • escrever uma referência a uma função existente que tenha a forma correta: [val task: () -> Unit = ::display];
  • escrever uma expressão lambda: [val task: () -> Unit = { println("task") }];
  • escrever uma função anônima: [val task = fun() { println("task") }], ou um objeto de uma classe que implemente o tipo funcional (um tipo funcional é uma interface, como veremos). Essas duas notações são menos comuns.

A função é então executada como uma função comum: [task()]. Essa é uma notação abreviada para a chamada ao método [invoke] do objeto função: [task.invoke()]. Esta é a primeira diferença perceptível em relação ao Java, em que é preciso chamar o método da interface pelo nome ([run], [apply], [test]…); aqui o Kotlin se comporta como o C#, em que um delegate é chamado como um método.

7.1.2. Tipos funcionais do Kotlin e interfaces de java.util.function

Antes do Java 8, cada biblioteca Java definia suas próprias interfaces de método único ([Runnable], [Comparator], [ActionListener]…). O Java 8 introduziu o pacote [java.util.function], que fornece 43 interfaces funcionais genéricas. O Kotlin não precisa delas: um tipo funcional é escrito diretamente. No entanto, essas interfaces ainda podem ser usadas a partir do Kotlin, e você as encontrará sempre que chamar uma biblioteca Java. A tabela a seguir relaciona as principais interfaces Java aos tipos funcionais do Kotlin:

Interface Java
Tipo Kotlin
Funções representadas
[Runnable]: [void run()]
[() -> Unit]
Sem parâmetros, sem resultado
[Supplier<T>] : [T get()]
[() -> T]
Sem parâmetros, um resultado: um “fornecedor”
[Consumer<T>]: [void accept(T t)]
[(T) -> Unit]
Um parâmetro, sem resultado: um “consumidor”
[BiConsumer<T, U>]
[(T, U) -> Unit]
Dois parâmetros, sem resultado
[Function<T, R>]: [R apply(T t)]
[(T) -> R]
Um parâmetro, um resultado
[BiFunction<T, U, R>]
[(T, U) -> R]
Dois parâmetros, um resultado
[UnaryOperator<T>]
[(T) -> T]
Parâmetro e resultado do mesmo tipo
[BinaryOperator<T>]
[(T, T) -> T]
Dois parâmetros e um resultado do mesmo tipo
[Predicate<T>]: [boolean test(T t)]
[(T) -> Boolean]
Um parâmetro, um resultado booleano: um “predicado”
[BiPredicate<T, U>]
[(T, U) -> Boolean]
Dois parâmetros, um resultado booleano
[Comparator<T>]: [int compare(T o1, T o2)]
[(T, T) -> Int]
Dois parâmetros do mesmo tipo, um resultado inteiro
[Callable<V>] : [V call()]
[() -> V]
como [Supplier<V>]; em Kotlin, não é necessário declarar nenhuma exceção verificada
[IntBinaryOperator], [IntPredicate]…
[(Int, Int) -> Int], [(Int) -> Boolean]…
As versões Java para tipos primitivos

Em Kotlin, não há limite prático para o número de parâmetros de um tipo funcional: [(Int, Int, Int) -> Int] é escrito tão simplesmente quanto os demais, ao passo que, em Java, como não há interface predefinida com três parâmetros, é preciso definir a sua própria.

Como a Máquina Virtual Java, que só reconhece classes e interfaces, representa um tipo funcional? Por meio de interfaces genéricas da biblioteca do Kotlin: [kotlin.jvm.functions.Function0<R>], [Function1<P1, R>], [Function2<P1, P2, R>]… até [Function22], seguida, além desse ponto, de uma interface [FunctionN] . Cada uma tem um único método, [invoke]: [(Int, Int) -> Int] é compilado em [Function2<Integer, Integer, Integer>], cujo método é [operator fun invoke(p1: Int, p2: Int): Int]. É o modificador [operator] de [invoke] (veja a sobrecarga de operadores no Capítulo 4) que permite a notação [f(2, 3)]. Um tipo funcional é, portanto, para a JVM, uma interface funcional como as do Java. Como os genéricos do Java se aplicam apenas a tipos de objeto, os valores [Int] passados a um [(Int, Int) -> Int] são convertidos em [Integer] e vice-versa (boxing e unboxing). O Java evita essas conversões com suas interfaces especializadas ([IntBinaryOperator]…); o Kotlin as evita de outra maneira, usando as funções [inline], que discutiremos mais adiante.

O programa [Lambdas01.kt] usa esses tipos com referências a funções:

package lambdas01

import java.util.function.IntBinaryOperator
import java.util.function.Predicate
import java.util.function.Supplier

// tipos de função do Kotlin e interfaces funcionais do Java

fun main() {
    // 1 - () -> Unit: sem parâmetro, sem resultado
    val task: () -> Unit = ::display
    // execução: a função é chamada como uma função comum
    task()
    // que é uma forma abreviada de chamar seu método invoke
    task.invoke()

    // 2 - (Int, Int) -> Int: dois parâmetros, um resultado
    val operation: (Int, Int) -> Int = ::add
    println("operation(2, 3)=${operation(2, 3)}")
    // () -> String: sem parâmetro, um resultado
    val greet: () -> String = ::greet
    println("greet()=${greet()}")

    // 3 - (String) -> Unit: um parâmetro, sem resultado
    val write: (String) -> Unit = ::println
    write("(String) -> Unit executed println")

    // 4 - (Int) -> Boolean: um predicado
    val isEven: (Int) -> Boolean = ::isEven
    println("isEven(8)=${isEven(8)}")
    val numbers = mutableListOf(3, 8, 1, 6, 5, 4)
    // removeAll da biblioteca Kotlin espera um (Int) -> Boolean
    val modified = numbers.removeAll(isEven)
    println("even numbers removed: $modified, remaining: $numbers")

    // 5 - um Comparator<T> (interface Java) construído a partir de uma função (conversão SAM)
    val names = mutableListOf("Paul", "Mélanie", "Jo", "Sébastien")
    names.sortWith(Comparator(::compareLengths))
    println("sorted by length: $names")

    // 6 - as interfaces de java.util.function continuam utilizáveis
    val supplier: Supplier<String> = Supplier(::greet)
    val multiply = IntBinaryOperator(::multiply)
    val predicate = Predicate<Int> { it > 4 }
    println("supplier.get()=${supplier.get()}")
    println("multiply.applyAsInt(2, 3)=${multiply.applyAsInt(2, 3)}")
    // removeIf é um método Java (Collection): ele espera um Predicate
    val values = mutableListOf(10, 3, 8, 7, 2, 1)
    values.removeIf(predicate)
    // uma função Kotlin é convertida automaticamente em um Predicate (conversão SAM)
    values.removeIf(isEven)
    values.removeIf { it == 1 }
    println("after removeIf: $values")

    // 7 - um tipo de função anulável: a função pode estar ausente
    execute(null)
    execute(task)

    // 8 - um tipo de função com receptor: String.(Int) -> String
    val times: String.(Int) -> String = String::repeat
    println("\"ab\".times(3)=${"ab".times(3)}, times(\"cd\", 2)=${times("cd", 2)}")

    // 9 - uma função é um objeto, uma instância de uma classe que implementa uma interface
    println("class: ${operation::class.java.name}")
    println("interfaces: ${operation::class.java.interfaces.contentToString()}")
    val sum: (Int, Int) -> Int = { n1, n2 -> n1 + n2 }
    println("class of the lambda: ${sum::class.java.name}")
    println("interfaces: ${sum::class.java.interfaces.contentToString()}")
}

// uma função que recebe uma função possivelmente ausente
fun execute(callback: (() -> Unit)?) {
    // chamada segura: nada é executado se callback for null
    callback?.invoke()
    println("callback ${if (callback == null) "absent" else "present"}")
}

// as funções referenciadas: funções de nível superior do arquivo
fun display() {
    println("display() executed by task()")
}

fun add(n1: Int, n2: Int): Int = n1 + n2

fun multiply(n1: Int, n2: Int): Int = n1 * n2

fun greet(): String = "Hello"

fun isEven(n: Int): Boolean = n % 2 == 0

fun compareLengths(s1: String, s2: String): Int = s1.length.compareTo(s2.length)

Resultados:

> gradlew -q run -Pmain=lambdas01.Lambdas01Kt
display() executed by task()
display() executed by task()
operation(2, 3)=5
greet()=Hello
(String) -> Unit executed println
isEven(8)=true
even numbers removed: true, remaining: [3, 1, 5]
sorted by length: [Jo, Paul, Mélanie, Sébastien]
supplier.get()=Hello
multiply.applyAsInt(2, 3)=6
after removeIf: [3]
callback absent
display() executed by task()
callback present
"ab".times(3)=ababab, times("cd", 2)=cdcd
class: lambdas01.Lambdas01Kt$main$operation$1
interfaces: [interface kotlin.jvm.functions.Function2]
class of the lambda: lambdas01.Lambdas01Kt$$Lambda/0x000000001f04a7f0
interfaces: [interface kotlin.jvm.functions.Function2]

Comentários:

  • linha 11: a variável [task] é do tipo [() -> Unit]. Atribui-se a ela uma referência de função: [::display] refere-se à função de nível superior [display] declarada mais adiante no arquivo (linha 79). O compilador verifica que ela tem a forma exigida (sem parâmetros, sem valor de retorno) e cria o objeto função que a chama. Em Java, seria necessária uma classe auxiliar para conter esses métodos, pois a classe implícita de um arquivo-fonte compacto não pode ser nomeada; em Kotlin, as funções de nível superior são referenciadas diretamente;
  • linha 13: a função é executada chamando-a como uma função comum. A função [display] é executada (linha 1 dos resultados). Linha 15: obtém-se o mesmo resultado chamando explicitamente o método [invoke] (linha 2 dos resultados);
  • Linha 18: [(Int, Int) -> Int] refere-se a uma função com dois parâmetros, [Int], e que retorna um [Int]. A função [add] (linha 83) é adequada. A função é chamada por meio de [operation(2, 3)] (linha 19);
  • linha 21: uma função sem parâmetros que retorna uma string, equivalente ao [Supplier<String>] do Java. Observe que a variável local [greet] tem o mesmo nome que a função [greet]: em [::greet], refere-se à função, e em [greet()], refere-se à variável local, que oculta a função;
  • Linha 25: uma função com um parâmetro, [String], que não retorna nada — equivalente ao [Consumer<String>] do Java. A função da biblioteca padrão [println] é sobrecarregada ([println(Int)], [println(Any?)]…): é o tipo esperado, [(String) -> Unit], que permite ao compilador escolher a sobrecarga correta;
  • Linha 29: um predicado, equivalente ao [Predicate<Integer>]. Linha 33: a função de extensão da biblioteca Kotlin [removeAll] espera justamente um parâmetro do tipo [(T) -> Boolean]: ela remove da lista mutável todos os elementos para os quais o predicado é avaliado como [true] e retorna [true] se removeu pelo menos um elemento (linha 7 dos resultados);
  • Linha 38: a função [sortWith] espera um [Comparator<T>]. Em Kotlin, [Comparator] é um alias da interface Java [java.util.Comparator]. [Comparator(::compareLengths)] cria um [Comparator<String>] a partir da função [compareLengths]: trata-se de uma conversão SAM (“Single Abstract Method”), que cria o objeto que implementa a interface Java a partir de uma função Kotlin da mesma forma. A função [compareLengths] (linha 91) usa [compareTo], que compara dois objetos [Int] sem o risco de estouro de capacidade (que uma simples subtração não garante);
  • linhas 42–44: as interfaces de *[java.util.function] podem ser usadas como estão. Elas são construídas da mesma maneira, por meio de uma conversão SAM explícita: o nome da interface seguido de uma referência a função ou de um lambda. Elas são então executadas por meio de seu método Java ([get], [applyAsInt]*, [test]…), exatamente como em Java;
  • linhas 49–52: [removeIf] é um método Java da interface [Collection]; ele espera um [Predicate]. Você pode passar a ele um *[Predicate] (linha 49), mas também diretamente um valor do tipo *[(Int) -> Boolean] (linha 51) ou um lambda (linha 52): ao chamar um método Java que espera uma interface funcional, o Kotlin faz automaticamente a conversão SAM. É isso que torna as bibliotecas Java tão agradáveis de usar a partir do Kotlin quanto a partir do Java. A lista inicial (10, 3, 8, 7, 2, 1) tem removidos sucessivamente os elementos maiores que 4, os elementos pares e, em seguida, o elemento 1 (linha 11 dos resultados);
  • linhas 56–57 e 72–75: a função *[execute] recebe uma função que pode estar ausente, do tipo *[(() -> Unit)?]. A chamada segura [callback?.invoke()] não faz nada se [callback] for igual a [null]. Não é possível escrever [callback?()]: a chamada segura a uma função anulável passa por [invoke]. Esta será a notação padrão para listeners opcionais;
  • Linha 60: um tipo funcional com receptor. A referência [String::repeat] refere-se ao método [repeat] da classe [String], que se aplica a uma string e recebe um inteiro. A linha 61 é referenciada de duas maneiras: como extensão, ["ab".times(3)], ou como função com dois parâmetros, [times("cd", 2)]. Voltaremos a ver funções com receptor nas funções de escopo [apply] e [with];
  • linhas 64–68: uma função é um objeto. A classe da referência de função [operation] (linha 16 da saída) é uma classe gerada pelo compilador Kotlin, nomeada de acordo com o local onde a referência aparece; a classe do lambda [sum] (linha 18 dos resultados) é gerada em tempo de execução pela máquina virtual, exatamente como os lambdas do Java: seu nome contém [$$Lambda] seguido de um endereço que muda de uma execução para outra. Em ambos os casos, a classe implementa a interface [kotlin.jvm.functions.Function2] (linhas 17 e 19 dos resultados). Uma função Kotlin não é, portanto, um novo tipo de objeto: é uma instância de uma classe comum que implementa uma interface funcional.

7.2. Definindo seus próprios tipos funcionais

Os tipos funcionais costumam ser suficientes, mas você pode querer dar um nome a um modelo de função. O Kotlin oferece duas ferramentas para isso, de natureza muito diferente.

A primeira é o alias de tipo, declarado com a palavra-chave [typealias]:

  • [typealias BinaryOperation = (n1: Int, n2: Int) -> Int]

Um alias não cria um novo tipo: [BinaryOperation] é outro nome para [(Int, Int) -> Int], e as duas notações são intercambiáveis. O alias torna o código mais legível quando o tipo funcional é longo ou aparece com frequência.

A segunda é a interface funcional, declarada com [fun interface]:

  • [fun interface Operation { fun calculate(n1: Int, n2: Int): Int }]

Este é o equivalente exato de uma interface funcional do Java: uma interface com apenas um método abstrato (também conhecida como interface SAM, ou “Single Abstract Method”). Ela também pode ter métodos com corpo e propriedades não abstratas; estes não contam. A palavra-chave [fun] que precede [interface] tem a mesma finalidade da anotação Java [@FunctionalInterface], com uma diferença importante: ela não é opcional. É essa palavra-chave que habilita a conversão SAM — isto é, a criação de um objeto [Operation] a partir de um lambda ou de uma referência de função: [Operation { n1, n2 -> n1 + n2 }]. Sem a palavra-chave [fun], uma interface Kotlin — mesmo reduzida a um único método — só pode ser implementada por uma classe ou por um objeto anônimo ([object : Operation { … }]).

Em comparação com o tipo [(Int, Int) -> Int], o tipo [Operation] é um tipo realmente novo, distinto de todos os outros: tem um nome que descreve sua finalidade, seu método tem um nome descritivo ([calculate] em vez de [invoke]), pode ter métodos adicionais e pode ser implementado por uma classe nomeada. Em contrapartida, ele é executado pelo nome de seu método ([op.calculate(2, 3)]), e não por [op(2, 3)].

Uma variável chamada [op] do tipo [Operation], assim como uma variável do tipo [(Int, Int) -> Int], referencia apenas uma função por vez. Diferentemente do C#, que oferece “delegates multicast”, nem o Java nem o Kotlin oferecem uma maneira de armazenar várias funções em uma única variável e executá-las todas com uma única chamada: quando necessário, armazenamos as funções em uma lista e as executamos uma a uma. É exatamente isso que faremos com os listeners de eventos.

Considere o exemplo [Lambdas02.kt]:

package lambdas02

import java.util.function.IntBinaryOperator

// definindo seus próprios tipos de função: fun interface e typealias

fun main() {
    // uma variável do tipo Operation recebe a função increase do companion object
    var op = Operation(Calculations::increase)
    // a operação é executada
    var n = op.calculate(4, 7)
    println("n=$n")

    // criação de um objeto c1 do tipo Calculations
    val c1 = Calculations()
    // op recebe o método add do objeto c1
    op = Operation(c1::add)
    n = op.calculate(2, 3)
    println("n=$n")
    // depois o método subtract de c1
    op = Operation(c1::subtract)
    n = op.calculate(2, 3)
    println("n=$n")

    // uma variável referencia apenas uma função: para executar várias, usa-se uma lista
    val operations = listOf(
        Operation(c1::add),
        Operation(c1::subtract),
        Operation { n1, n2 -> n1 * n2 },
    )
    for (operation in operations) {
        println("-> ${operation.calculate(10, 4)}")
    }

    // um método da interface constrói uma nova operação
    val squaredSum = Operation(c1::add).then { x -> x * x }
    println("squaredSum.calculate(1, 2)=${squaredSum.calculate(1, 2)}")

    // Operation e IntBinaryOperator têm a mesma forma, mas são dois tipos diferentes
    val other = IntBinaryOperator(op::calculate)
    println("other.applyAsInt(5, 1)=${other.applyAsInt(5, 1)}")

    // uma interface funcional genérica
    val length = Transformation(String::length)
    val stars = Transformation("*"::repeat)
    println("length(\"Hello\")=${length.transform("Hello")}")
    println("stars(5)=${stars.transform(5)}")

    // um alias de tipo: simplesmente outro nome para (Int, Int) -> Int
    val f: BinaryOperation = { n1, n2 -> n1 - n2 }
    // BinaryOperation e (Int, Int) -> Int são o mesmo tipo
    val g: (Int, Int) -> Int = f
    // mas Operation é um tipo diferente: é necessária uma conversão
    val op2 = Operation(g)
    println("f(5, 1)=${f(5, 1)}, g(5, 1)=${g(5, 1)}, op2.calculate(5, 1)=${op2.calculate(5, 1)}")
}

// definição de uma interface funcional: um único método abstrato
// que recebe dois inteiros como parâmetros e devolve um inteiro
fun interface Operation {
    fun calculate(n1: Int, n2: Int): Int

    // um método com corpo não conta: a interface continua funcional
    fun then(next: (Int) -> Int): Operation = Operation { n1, n2 -> next(calculate(n1, n2)) }
}

// uma interface funcional genérica: T -> R
fun interface Transformation<T, R> {
    fun transform(value: T): R
}

// um alias de tipo: nenhum novo tipo é criado
typealias BinaryOperation = (n1: Int, n2: Int) -> Int

// uma classe cujos métodos têm a forma da interface Operation
class Calculations {
    // dois métodos de instância
    fun add(n1: Int, n2: Int): Int {
        println("add($n1,$n2)")
        return n1 + n2
    }

    fun subtract(n1: Int, n2: Int): Int {
        println("subtract($n1,$n2)")
        return n1 - n2
    }

    // um método do companion object: o equivalente a um método estático
    companion object {
        fun increase(n1: Int, n2: Int): Int {
            println("increase($n1,$n2)")
            return n1 + 2 * n2
        }
    }
}

Resultados:

> gradlew -q run -Pmain=lambdas02.Lambdas02Kt
increase(4,7)
n=18
add(2,3)
n=5
subtract(2,3)
n=-1
add(10,4)
-> 14
subtract(10,4)
-> 6
-> 40
add(1,2)
squaredSum.calculate(1, 2)=9
subtract(5,1)
other.applyAsInt(5, 1)=4
length("Hello")=5
stars(5)=*****
f(5, 1)=4, g(5, 1)=4, op2.calculate(5, 1)=4

Comentários:

  • linhas 60–64: definição da interface funcional [Operation]. Em Kotlin, as declarações de tipos podem ser colocadas em qualquer lugar do arquivo, antes ou depois da função [main]; nós as colocamos depois dela;
  • Linha 64: uma interface funcional pode ter métodos com corpo (o equivalente aos métodos [default] do Java). O método [then] constrói uma nova [Operation]: esse objeto executa a operação atual e, em seguida, aplica a função [next] ao seu resultado. Ele retorna um lambda convertido em [Operation], que examinaremos na próxima seção. Observe que o parâmetro [next] não requer uma interface como a [IntUnaryOperator] da versão Java: o tipo funcional [(Int) -> Int] é suficiente, e ele é executado por meio de [next(…)];
  • linhas 76–89: a classe [Calculations] tem dois métodos de instância, [add] e [subtract], e um método de seu objeto companheiro, [increase] (o equivalente a um método estático, veja o Capítulo 4), todos os três com a mesma forma que o método [calculate];
  • linha 9: a variável [op] é do tipo [Operation]. Atribui-se a ela o objeto obtido ao converter para SAM a referência [Calculations::increase], que se refere ao método [increase] do objeto companheiro da classe [Calculations]. A conversão deve ser escrita da seguinte forma: [Operation(Calculations::increase)] se parece com uma chamada de construtor, mas uma interface não tem construtor; o compilador cria o objeto que implementa [Operation];
  • linha 11: a operação é executada pelo método [calculate] . O método [increase] é o que de fato executa, com os parâmetros passados a [calculate];
  • Linha 15: uma instância da classe [Calculations] com o identificador [c1] é criada;
  • Linha 17: a referência [c1::add] refere-se ao método [add] do objeto [c1]: isso é chamado de “referência vinculada”. [increase] era um método do objeto companheiro, enquanto [add] é um método de instância: isso não faz diferença. No segundo caso, o objeto criado pelo compilador também armazena o objeto [c1] sobre o qual o método será chamado;
  • linha 21: faz-se o mesmo com o método de instância [subtract];
  • linhas 26–32: para executar várias operações, elas são colocadas em uma lista do tipo [List<Operation>] (tipo inferido), que é então percorrida. Referências e lambdas podem ser misturados (linha 29). Cada resultado é recuperado (linhas 7–11 dos resultados);
  • linha 36: o método [then] é aplicado à operação [Operation(c1::add)]. O lambda [{ x -> x * x }] é passado fora dos parênteses porque é o último (e, neste caso, o único) parâmetro de [then]: explicaremos essa sintaxe com mais detalhes na próxima seção. [squaredSum.calculate(1, 2)] calcula (1+2)², que é 9 (linhas 12–13 dos resultados). Em Java, a conversão [((Operation) c1::add).then(…)] precisava ser escrita explicitamente; em Kotlin, a conversão SAM explícita cumpre esse papel;
  • Linha 40: [Operation] e a interface Java [IntBinaryOperator] têm exatamente a mesma forma, mas são dois tipos diferentes, sem relação de herança. A atribuição [val other: IntBinaryOperator = op] seria rejeitada ([initializer type mismatch: expected 'IntBinaryOperator', actual 'Operation']). Em contrapartida, a referência [op::calculate] é uma função do tipo [(Int, Int) -> Int]: a conversão SAM a transforma em um [IntBinaryOperator], que chama o método [calculate] do objeto [op] ([c1::subtract] nesta etapa do programa);
  • linhas 68–69: uma interface funcional pode ser genérica. [Transformation<T, R>] representa uma função que recebe um [T] e retorna um [R]: isso equivale a [(T) -> R], com nomes escolhidos por nós;
  • Linha 44: [String::length] refere-se à propriedade [length] da classe [String]: uma referência pode apontar tanto para uma propriedade quanto para uma função. Ela é usada como uma função do tipo [(String) -> Int]: a propriedade será lida da string passada como parâmetro. Os tipos [T = String] e [R = Int] de [Transformation] são inferidos a partir da referência. Linha 45: ["*"::repeat] refere-se ao método [repeat(Int)] do objeto string ["*"]: ele recebe um inteiro e retorna uma string. São dois tipos diferentes de referências (não vinculada, vinculada), que discutiremos em detalhes na próxima seção;
  • linha 73: um alias de tipo. Os parâmetros chamados [n1] e [n2] servem apenas como documentação;
  • linhas 50–54: o lambda [f] do tipo [BinaryOperation] é atribuído sem conversão à variável [g] do tipo [(Int, Int) -> Int]: eles são o mesmo tipo. Para convertê-lo em uma [Operation], porém, é necessária uma conversão SAM (linha 54).

Essas regras podem ser verificadas provocando erros. Se você escrever ***[var op: Operation = Calculations::increase]*** sem uma conversão explícita, o compilador a rejeitará:

1
2
3
Lambdas02.kt:9:23: error: initializer type mismatch: expected 'Operation', actual 'KFunction2<Int, Int, Int>'.
    var op: Operation = Calculations::increase
                      ^

A mensagem também revela o tipo de uma referência de função: [KFunction2<Int, Int, Int>], um tipo de reflexão do Kotlin ([kotlin.reflect]) que também é um [(Int, Int) -> Int]. A conversão SAM implícita ocorre apenas para os argumentos de uma chamada de função (por exemplo, [values.removeIf(isEven)]), e não para uma atribuição.

Se um segundo método abstrato, como [fun invert(n: Int): Int], for adicionado por engano à interface [Operation], o compilador sinaliza a própria declaração e cada uma das conversões SAM que usam a interface (saída abreviada):

1
2
3
4
5
6
7
8
Lambdas02.kt:9:14: error: interface 'fun interface Operation : Any' does not have constructors.
    var op = Operation(Calculations::increase)
             ^^^^^^^^^
...
Lambdas02.kt:60:1: error: functional interface must have exactly one abstract function.
fun interface Operation {
^^^
...

Essas mensagens vêm do compilador [kotlinc]; o Gradle as exibe precedidas de [e:] e do caminho completo do arquivo. Como as do [javac], elas estão em inglês.

7.3. Objetos anônimos, expressões lambda e referências

7.3.1. De objetos anônimos a lambdas

Nos exemplos anteriores, cada função é uma função nomeada, definida em outro ponto do programa. Para funções curtas usadas uma única vez, isso é trabalhoso. O Java oferecia originalmente a classe anônima: a classe que implementa a interface é definida exatamente onde o objeto é criado. O Kotlin tem um equivalente — a expressão de objeto [object : Type { … }], apresentada no Capítulo 4 — mas raramente a usa para representar uma função: desde o início, o Kotlin oferece suporte a expressões lambda, que têm uma sintaxe muito mais concisa. O programa [Lambdas03.kt] demonstra as diferentes formas:

package lambdas03

// de objetos anônimos a expressões lambda

fun main() {
    // 1 - um objeto anônimo: a classe que implementa o tipo de função é escrita na hora
    val add = object : (Int, Int) -> Int {
        override fun invoke(n1: Int, n2: Int): Int {
            return n1 + n2
        }
    }
    println("anonymous object: add(2, 3)=${add(2, 3)}")

    // 2 - a mesma coisa com uma expressão lambda: { parâmetros -> corpo }
    val subtract = { n1: Int, n2: Int -> n1 - n2 }
    println("lambda with typed parameters: subtract(2, 3)=${subtract(2, 3)}")

    // 3 - os tipos dos parâmetros são inferidos a partir do tipo esperado
    val multiply: (Int, Int) -> Int = { n1, n2 -> n1 * n2 }
    println("lambda with untyped parameters: multiply(2, 3)=${multiply(2, 3)}")

    // 4 - um único parâmetro: não precisa ser nomeado, ele se chama it
    val square: (Int) -> Int = { it * it }
    val isEmpty: (String) -> Boolean = { s -> s.isEmpty() }
    println("square(7)=${square(7)}, isEmpty(\"\")=${isEmpty("")}")

    // 5 - sem parâmetro: sem seta
    val greet = { "Hello" }
    val beep = { println("beep!") }
    println(greet())
    beep()

    // 6 - um corpo de várias instruções: o valor da última expressão é o resultado
    val repeat: (String, Int) -> String = { text, times ->
        val buffer = StringBuilder()
        for (i in 1..times) {
            buffer.append(text)
        }
        buffer.toString()
    }
    println(repeat("ab", 3))

    // 7 - parâmetros não usados: _
    val listener: (Any?, String) -> Unit = { _, _ -> println("event received") }
    listener(null, "click")

    // 8 - uma lambda passada como parâmetro: fora dos parênteses se for o último parâmetro
    val numbers = mutableListOf(3, 8, 1, 6, 5, 4)
    val evens = numbers.filter { it % 2 == 0 }
    println("evens: $evens")
    numbers.sortWith { n1, n2 -> n2.compareTo(n1) }
    println("descending order: $numbers")
    // a lambda fora dos parênteses, depois de outros parâmetros
    val total = numbers.fold(0) { acc, n -> acc + n }
    println("total: $total")

    // 9 - return em uma lambda: return@label sai apenas da lambda
    numbers.forEach {
        if (it % 2 == 0) return@forEach
        print("$it ")
    }
    println("<- odds")
    // um rótulo escolhido pelo desenvolvedor
    numbers.forEach odd@{ n ->
        if (n % 2 != 0) return@odd
        print("$n ")
    }
    println("<- evens")
    // uma função anônima: return nela sai da função anônima
    val isLarge = fun(n: Int): Boolean {
        if (n > 5) return true
        return false
    }
    println("large: ${numbers.filter(isLarge)}")

    // 10 - desestruturação dos parâmetros de uma lambda
    val ages = mapOf("Paul" to 40, "Mélanie" to 35)
    ages.forEach { (name, age) -> println("$name is $age years old") }
}

Resultados:

> gradlew -q run -Pmain=lambdas03.Lambdas03Kt
anonymous object: add(2, 3)=5
lambda with typed parameters: subtract(2, 3)=-1
lambda with untyped parameters: multiply(2, 3)=6
square(7)=49, isEmpty("")=true
Hello
beep!
ababab
event received
evens: [8, 6, 4]
descending order: [8, 6, 5, 4, 3, 1]
total: 27
5 3 1 <- odds
8 6 4 <- evens
large: [8, 6]
Paul is 40 years old
Mélanie is 35 years old

Comentários:

  • linhas 7–12: um objeto anônimo. A palavra-chave [object] é seguida de dois-pontos e do tipo a implementar — neste caso, o tipo funcional [(Int, Int) -> Int] (que é uma interface, como vimos) — e do corpo de uma classe que implementa esse tipo redefinindo seu método [invoke]. O compilador gera uma classe sem nome e cria uma instância dela. São seis linhas para expressar [n1 + n2]. Ainda assim, ele é executado como uma função: [add(2, 3)];
  • linha 15: a mesma coisa com uma expressão lambda. Um lambda é escrito entre chaves: a lista de parâmetros, o operador [->] (uma seta, que se lê “resulta em”) e, depois, o corpo. O nome do tipo e o nome do método desapareceram. Como os parâmetros são tipados, o compilador consegue determinar sozinho o tipo do lambda: [(Int, Int) -> Int]. Isso difere do Java, em que um lambda nunca tem um tipo próprio;
  • linha 19: os tipos dos parâmetros foram omitidos. O compilador os infere a partir do tipo esperado declarado para a variável: [n1] e [n2] são do tipo [Int]. Esta é a forma mais comum. Em Kotlin, não há distinção entre “corpo de expressão” e “corpo de bloco”, como há em Java: o corpo de um lambda é uma sequência de instruções, e o valor da última expressão é o resultado do lambda;
  • Linha 23: com um único parâmetro, não é preciso declará-lo, nem usar a seta; ele passa a se chamar implicitamente [it] (“it”, “isso”). [{ it * it }] lê-se “o quadrado dele”. Linha 24: o único parâmetro se chama [s]. Isso é feito quando [it] tornaria o código menos legível, especialmente quando há lambdas aninhados (cada um teria seu próprio [it]);
  • Linhas 28–29: sem parâmetro, não há seta. O tipo de *[greet]* é inferido como *[() -> String]*; o tipo de *[beep] é *[() -> Unit]*, já que *[println] produz *[Unit]*;
  • Linhas 34–39: um lambda pode conter quaisquer instruções: declarações, laços, testes etc. O valor da última expressão, [buffer.toString()], é o resultado. Não é possível escrever [return buffer.toString()]: em um lambda, um [return] sem rótulo não sai do lambda (veja adiante);
  • linha 44: o caractere sublinhado [_] denota um parâmetro não utilizado. Ele é usado quando a assinatura do tipo exige parâmetros de que o lambda não precisa, o que é comum em listeners de eventos. Você pode incluir vários desses parâmetros no mesmo lambda (o Java adotou essa sintaxe na versão 22);
  • Linhas 48–49: o uso mais comum dos lambdas é passá-los diretamente como parâmetros a uma função de ordem superior. Quando o lambda é o último parâmetro, ele é escrito fora dos parênteses; se não houver outros parâmetros, os parênteses são omitidos: [numbers.filter { it % 2 == 0 }] em vez de [numbers.filter({ it % 2 == 0 })]. É essa regra que dá ao código Kotlin seu aspecto característico e permite escrever funções que se parecem com instruções da linguagem ([repeat], [use], [thread], [synchronized]…). Compare com [Lambdas01.kt]: não é mais necessário escrever uma função [isEven];
  • linha 51: um lambda que inverte a comparação usual: a lista é ordenada em ordem decrescente. [sortWith] espera um [Comparator] (uma interface Java): a conversão para SAM é feita automaticamente;
  • linha 54: o lambda permanece fora dos parênteses quando a função tem outros parâmetros: [fold(0) { acc, n -> acc + n }]. A função [fold] (Capítulo 5) começa com o valor inicial 0 e soma os elementos um a um;
  • linhas 58–62: dentro de um lambda, a instrução [return@forEach] sai do lambda (e, portanto, passa ao próximo elemento), exatamente como um [continue] em um laço. O rótulo [@forEach] é implícito: é o nome da função à qual o lambda é passado. Um [return] sem rótulo sairia da função [main] inteira: isso é chamado de retorno não local e só é permitido em um lambda passado a uma função [inline] como [forEach] (veremos por quê);
  • linhas 64–68: você também pode escolher o rótulo colocando-o antes da chave de abertura: [odd@{ … }], depois [return@odd];
  • linhas 70–74: uma função anônima. Ela é escrita como uma função comum, mas sem nome. Seu tipo é inferido: [(Int) -> Boolean]. Em uma função anônima, [return] sai da própria função anônima. Isso é usado quando o corpo tem vários pontos de saída ou quando se quer especificar explicitamente o tipo do resultado;
  • Linha 78: os parâmetros de um lambda podem ser desestruturados (Capítulo 3). O lambda passado a [forEach] recebe uma entrada do array associativo ([Map.Entry<String, Int>]); a notação [(name, age)], entre parênteses, a decompõe em chave e valor. Atenção: [{ name, age -> … }] declararia dois parâmetros, enquanto [{ (name, age) -> … }] declararia um único parâmetro decomposto.

Vamos revisar as formas de uma expressão lambda:

Forma
Exemplo
Parâmetros tipados
[{ a: Int, b: Int -> a + b }]
Parâmetros sem tipo (tipo esperado conhecido)
[{ a, b -> a + b }]
Um único parâmetro, implícito
[{ it * it }]
Sem parâmetros
[{ "Hello" }]
Parâmetros não utilizados
[{ _, _ -> println("received") }]
Parâmetro desestruturado
[{ (key, value) -> "$key=$value" }]
Várias instruções
[{ x -> println(x) ; x * 2 }]
Lambda como último parâmetro
[list.filter { it > 0 }]
Função anônima
[fun(x: Int): Int { return x * 2 }]

Um lambda não é exatamente uma abreviação de um objeto anônimo. Em um objeto anônimo, [this] refere-se ao próprio objeto anônimo; em um lambda, [this] refere-se ao objeto do método que contém o lambda (ou ao receptor, no caso de um lambda com receptor). Além disso, um objeto anônimo pode implementar uma interface com vários métodos, várias interfaces ao mesmo tempo ou herdar de uma classe — o que é impossível com um lambda. Neste curso, usaremos lambdas sempre que possível.

7.3.2. Informações adicionais: inferência de tipos e referências

O programa [Lambdas04.kt] explica como o tipo de um lambda é determinado e descreve os diferentes tipos de referências:

package lambdas04

import java.io.IOException
import java.util.concurrent.Callable
import java.util.function.Supplier

// mais sobre lambdas e referências

fun main() {
    // 1 - o tipo de uma lambda é inferido a partir de seus parâmetros e de seu corpo...
    val double = { x: Int -> x * 2 }
    println("double(21)=${double(21)}")
    // ... ou fixado pelo tipo esperado: o mesmo texto de lambda pode resultar em três tipos diferentes
    val function: () -> String = { "Hello" }
    val supplier = Supplier { "Hello" }
    val callable = Callable { "Hello" }
    println("${function()} / ${supplier.get()} / ${callable.call()}")

    // 2 - os tipos de referências
    // a) função de nível superior: ::function
    val triple: (Int) -> Int = ::triple
    println("triple(14)=${triple(14)}")
    // b) método ou propriedade de um objeto específico (referência vinculada): object::method
    val name = "Pierre"
    val inUpperCase: () -> String = name::uppercase
    val nameLength: () -> Int = name::length
    println("inUpperCase()=${inUpperCase()}, nameLength()=${nameLength()}")
    // c) método de qualquer objeto da classe (referência não vinculada): Class::method
    //    o objeto sobre o qual o método é chamado torna-se o primeiro parâmetro
    val upperCase: (String) -> String = String::uppercase
    val ignoreCase: (String, String) -> Int = { s1, s2 -> s1.compareTo(s2, ignoreCase = true) }
    println("upperCase(\"paul\")=${upperCase("paul")}")
    println("ignoreCase(\"abc\", \"ABC\")=${ignoreCase("abc", "ABC")}")
    // d) função de extensão: Class::extension
    val convert: (String) -> Int = String::toInt
    println("convert(\"42\") + 1 = ${convert("42") + 1}")
    // e) construtor: ::Class
    val createList: () -> MutableList<String> = ::ArrayList
    val createBuffer: (String) -> StringBuilder = ::StringBuilder
    val createArray: (Int) -> IntArray = ::IntArray
    val createPerson: (String, Int) -> Person = ::Person
    val list = createList()
    list.add("element")
    println("$list ${createBuffer("abc").reverse()} ${createArray(3).size} ${createPerson("Paul", 40)}")

    // 3 - sem exceções verificadas: qualquer lambda pode lançar qualquer exceção
    val read: () -> Int = { throw IOException("file missing") }
    try {
        read()
    } catch (ex: IOException) {
        println("exception received: ${ex.message}")
    }

    // 4 - igualdade de funções: referências são comparáveis, lambdas não são
    val r1: () -> String = name::uppercase
    val r2: () -> String = name::uppercase
    val l1 = { name.uppercase() }
    val l2 = { name.uppercase() }
    println("r1 == r2 : ${r1 == r2}, r1 === r2 : ${r1 === r2}, l1 == l2 : ${l1 == l2}")
}

fun triple(n: Int) = n * 3

// uma data class, para a referência ao seu construtor
data class Person(val name: String, val age: Int)

Resultados:

> gradlew -q run -Pmain=lambdas04.Lambdas04Kt
double(21)=42
Hello / Hello / Hello
triple(14)=42
inUpperCase()=PIERRE, nameLength()=6
upperCase("paul")=PAUL
ignoreCase("abc", "ABC")=0
convert("42") + 1 = 43
[element] cba 3 Person(name=Paul, age=40)
exception received: file missing
r1 == r2 : true, r1 === r2 : false, l1 == l2 : false

Comentários:

  • linha 11: o lambda [{ x: Int -> x * 2 }] tem seu próprio tipo, [(Int) -> Int], calculado a partir do tipo de seu parâmetro e do de seu corpo. Já a declaração [val double = { x -> x * 2 }], é rejeitada: o compilador não consegue inferir o tipo de [x] ([an explicit type is required on a value parameter]). Em Java, [var twice = x -> x * 2;] é rejeitado por uma razão mais fundamental: um lambda Java não pode existir sem um tipo-alvo, que especifica a interface a implementar;
  • linhas 14–16: a mesma expressão lambda, [{ "Hello" }], produz [() -> String] aqui, [Supplier<String>] ali e [Callable<String>] em outro ponto. Nos dois últimos casos, é o nome da interface Java — colocado antes do lambda — que dispara a conversão para SAM. São três objetos de classes diferentes, que compartilham apenas a forma de seu método;
  • linhas 19–41: os tipos de referências. O Kotlin as chama de “referências a chamáveis” (callable references): elas se referem a funções, mas também a propriedades e construtores:
    • linha 21: a referência a uma função de nível superior, [::function]. [::triple] equivale ao lambda [{ n -> triple(n) }]. Ela substitui a referência a um método estático em Java ([Class::staticMethod]). Para uma função de um objeto companheiro, escrevemos [Class::function], como em [Lambdas02.kt];
    • linhas 25–26: a referência a um método ou propriedade de um objeto específico, [object::method], chamada de referência vinculada. [name::uppercase] equivale a [{ name.uppercase() }]: o objeto [name] é fixado de uma vez por todas. [name::length] referencia a propriedade [length] da string [name];
    • Linhas 30–31: a referência a um método de qualquer objeto de uma classe, [Class::method], conhecida como referência não vinculada. O objeto sobre o qual o método será chamado ainda não é conhecido: ele se torna o primeiro parâmetro da função. [String::uppercase] equivale a [{ s: String -> s.uppercase() }]. Para [ignoreCase], preferiu-se um lambda, o que permite passar o argumento nomeado [ignoreCase = true] a [compareTo];
    • linha 35: uma função de extensão é referenciada como um método: [String::toInt] equivale a [{ s: String -> s.toInt() }];
    • Linhas 38–41: a referência a um construtor, [::Class] (em Java: [Class::new]). [::ArrayList] equivale a [{ ArrayList() }]; [::StringBuilder], com o tipo esperado [(String) -> StringBuilder], seleciona o construtor que recebe uma string; [::IntArray] cria um array de inteiros com o tamanho passado como parâmetro; [::Person] refere-se ao construtor primário da data class [Person] (linha 65);
  • linha 44: as funções de criação são usadas; [reverse] inverte o conteúdo do [StringBuilder] (linha 8 dos resultados);
  • Linhas 47–51: o Kotlin não oferece suporte a exceções verificadas (Capítulo 3). Um lambda do tipo [() -> Int] pode, portanto, lançar uma [IOException] sem declarar nada. Em Java, isso era um verdadeiro desafio: nenhuma interface de [java.util.function] permite exceções verificadas, e um lambda do tipo [Supplier<Integer>] que lança uma [IOException] é rejeitado; era preciso, então, usar [Callable], cujo método é declarado como [throws Exception]. Observe também que o lambda [{ throw IOException("file missing") }] é aceito como um [() -> Int]: a expressão [throw] é do tipo [Nothing], que é compatível com todos os tipos;
  • linhas 55–59: duas avaliações da mesma referência ***[name::uppercase] produzem dois objetos diferentes ([r1 === r2] é igual a *[false]*), mas, diferentemente do Java, o Kotlin os considera *iguais no sentido de [equals] ([r1 == r2] é igual a [true]): duas referências são iguais se se referem à mesma função, associada ao mesmo objeto. Dois lambdas, mesmo com texto idêntico, nunca são iguais (linha 10 dos resultados). Tenha isso em mente: será importante ao cancelar o registro de um listener de eventos. Por fim, observe que o tipo de *[r1] precisou ser escrito: a função [uppercase] é sobrecarregada ([uppercase()] e [uppercase(locale: Locale)]) e, sem um tipo esperado, o compilador se recusa a escolher ([overload resolution ambiguity between candidates]*).

Uma referência é simplesmente uma notação abreviada de um lambda que apenas chama uma função. Ela é usada quando melhora a legibilidade: [String::length] em vez de [{ it.length }]. Na prática, com [it], os lambdas do Kotlin são tão curtos que as referências são usadas um pouco menos do que em Java.

7.3.3. Composição de funções

As interfaces funcionais do Java têm métodos [default] e [static] que criam novas funções a partir de funções existentes: [andThen], [compose], [and], [or], [negate]… Os tipos funcionais do Kotlin não os têm: a biblioteca padrão não fornece uma função [andThen] para um [(A) -> B]. Mas é muito fácil escrevê-las você mesmo, como funções de extensão sobre tipos funcionais (Capítulo 4), já que uma função pode retornar uma função. O programa [Lambdas05.kt] demonstra isso e, em seguida, apresenta as funções da biblioteca Kotlin que constroem comparadores:

package lambdas05

import java.util.function.Function

// compondo funções: funções que devolvem funções

fun main() {
    // 1 - composição: nossas extensões then (primeiro this, depois a outra) e after (primeiro a outra)
    val plusOne: (Int) -> Int = { it + 1 }
    val timesTwo: (Int) -> Int = { it * 2 }
    println("(plusOne then timesTwo)(5)=${(plusOne then timesTwo)(5)}")
    println("(plusOne after timesTwo)(5)=${(plusOne after timesTwo)(5)}")
    // os métodos da interface Function do Java continuam disponíveis
    val f = Function<Int, Int> { it + 1 }.andThen { it * 2 }
    println("Function.andThen: f.apply(5)=${f.apply(5)}")
    // uma função que fabrica funções
    val plusTen = adder(10)
    println("adder(10)(5)=${plusTen(5)}, adder(3)(5)=${adder(3)(5)}")
    // uma cadeia de processamento construída a partir de uma lista de funções
    val steps: List<(String) -> String> = listOf(String::trim, String::lowercase, { it.replace(' ', '-') })
    val normalize = steps.fold({ s: String -> s }) { function, step -> function then step }
    println("normalize(\"  My Nice Title \")=${normalize("  My Nice Title ")}")

    // 2 - predicados: nossas extensões and, or, not
    val short: (String) -> Boolean = { it.length <= 4 }
    val startsWithP: (String) -> Boolean = { it.startsWith("P") }
    val firstNames = listOf("Paul", "Mélanie", "Jo", "Sébastien", "Pierre")
    println("short and P: ${filterElements(firstNames, short and startsWithP)}")
    println("short or P: ${filterElements(firstNames, short or startsWithP)}")
    println("not short: ${filterElements(firstNames, !short)}")
    // um predicado sobre CharSequence serve para filtrar Strings
    val notEmpty: (CharSequence) -> Boolean = { it.isNotEmpty() }
    println("not empty: ${filterElements(listOf("a", "", "b"), notEmpty)}")

    // 3 - vários processamentos do mesmo valor
    val log = mutableListOf<String>()
    val display: (String) -> Unit = { println("display: $it") }
    val remember: (String) -> Unit = { log.add(it) }
    val both = display andAlso remember
    both("first")
    both("second")
    println("log: $log")

    // 4 - comparadores: compareBy, thenBy, thenByDescending, reversed
    val persons = mutableListOf(Person("Paul", 32), Person("Mélanie", 25),
        Person("Jo", 32), Person("Sébastien", 25))
    persons.sortWith(compareBy(Person::age).thenBy(Person::name))
    println("by age then name: $persons")
    persons.sortWith(compareBy(Person::age).reversed().thenByDescending(Person::name))
    println("by descending age then descending name: $persons")
    // vários critérios ao mesmo tempo
    persons.sortWith(compareBy({ it.name.length }, { it.name }))
    println("by name length then name: $persons")
    // um comparador também serve para escolher o menor de dois elementos
    val byAge = compareBy(Person::age)
    println("younger of Paul and Mélanie: ${minOf(persons[1], persons[2], byAge)}")
}

// composição: primeiro this, depois next
infix fun <A, B, C> ((A) -> B).then(next: (B) -> C): (A) -> C = { x -> next(this(x)) }

// composição inversa: primeiro before, depois this
infix fun <A, B, C> ((B) -> C).after(before: (A) -> B): (A) -> C = { x -> this(before(x)) }

// as operações lógicas sobre predicados
infix fun <T> ((T) -> Boolean).and(other: (T) -> Boolean): (T) -> Boolean = { this(it) && other(it) }

infix fun <T> ((T) -> Boolean).or(other: (T) -> Boolean): (T) -> Boolean = { this(it) || other(it) }

operator fun <T> ((T) -> Boolean).not(): (T) -> Boolean = { !this(it) }

// dois processamentos sucessivos do mesmo valor
infix fun <T> ((T) -> Unit).andAlso(other: (T) -> Unit): (T) -> Unit = { this(it); other(it) }

// uma função que devolve uma função
fun adder(n: Int): (Int) -> Int = { it + n }

// mantém os elementos que satisfazem o predicado
fun <T> filterElements(elements: List<T>, predicate: (T) -> Boolean): List<T> {
    val result = mutableListOf<T>()
    for (element in elements) {
        if (predicate(element)) {
            result.add(element)
        }
    }
    return result
}

data class Person(val name: String, val age: Int) {
    override fun toString() = "$name($age)"
}

Resultados:

> gradlew -q run -Pmain=lambdas05.Lambdas05Kt
(plusOne then timesTwo)(5)=12
(plusOne after timesTwo)(5)=11
Function.andThen: f.apply(5)=12
adder(10)(5)=15, adder(3)(5)=8
normalize("  My Nice Title ")=my-nice-title
short and P: [Paul]
short or P: [Paul, Jo, Pierre]
not short: [Mélanie, Sébastien, Pierre]
not empty: [a, b]
display: first
display: second
log: [first, second]
by age then name: [Mélanie(25), Sébastien(25), Jo(32), Paul(32)]
by descending age then descending name: [Paul(32), Jo(32), Sébastien(25), Mélanie(25)]
by name length then name: [Jo(32), Paul(32), Mélanie(25), Sébastien(25)]
younger of Paul and Mélanie: Mélanie(25)

Comentários:

  • Linha 60: a função de extensão [then] é aplicada a uma função do tipo [(A) -> B] (os parênteses em torno do tipo funcional são obrigatórios) e recebe uma função [next] do tipo [(B) -> C]. Ela retorna uma nova função do tipo [(A) -> C] — o lambda [{ x -> next(this(x)) }] — que aplica primeiro a função [this] (o receptor da extensão) e, depois, [next] ao seu resultado. Este é o método [andThen] da interface Java [Function]. Os três parâmetros de tipo [A], [B] e [C] são genéricos: [then] compõe quaisquer funções de um único parâmetro, desde que o resultado da primeira função seja adequado para a segunda. O modificador [infix] permite escrever [f then g] em vez de [f.then(g)];
  • linha 63: a composição inversa, equivalente ao método Java [compose]: [f after g] aplica primeiro [g] e depois [f];
  • linha 11: [plusOne then timesTwo] retorna a função que aplica primeiro [plusOne] e depois [timesTwo] ao resultado: (5 + 1) × 2 = 12. Os parênteses em torno da composição são necessários para poder chamar a função resultante;
  • Linha 12: [plusOne after timesTwo] aplica primeiro [timesTwo] e depois [plusOne]: 5 × 2 + 1 = 11;
  • linha 14: se você preferir os métodos da interface Java, basta criar uma [Function] por conversão SAM: [andThen] fica então disponível, e você pode passar a ele um lambda Kotlin, que por sua vez é convertido. O resultado é uma *[Function], que é executada por *[apply];
  • linhas 17–18 e 76: [adder] é uma função que retorna uma função: [adder(10)] retorna a função que soma 10 ao seu parâmetro. A função retornada pode ser armazenada em uma variável ([plusTen]) ou chamada imediatamente: [adder(3)(5)]. Esse processo, que consiste em fixar um parâmetro para obter uma função dos parâmetros restantes, é chamado de aplicação parcial;
  • linhas 20–21: uma cadeia de processamento construída dinamicamente. Partimos da função identidade ([{ s: String -> s }], que retorna seu parâmetro inalterado) e, usando [then], acrescentamos a ela cada etapa da lista, graças à função [fold] (Capítulo 5): o valor acumulado, [function], é aqui uma função. A função resultante [normalize] remove os espaços no início e no fim ([trim]), converte o texto para minúsculas e substitui os espaços por hifens. Cada chamada a [then] cria uma nova função: as funções existentes nunca são modificadas. Da mesma forma, a lista de etapas poderia ser lida de um arquivo de configuração;
  • Linhas 66–70: os predicados se combinam com nossas extensões [and], [or], e [not]. Esta última é declarada como [operator]: é a função chamada pelo operador [!] (veja a sobrecarga de operadores no Capítulo 4). Assim, escreve-se [!short] para a negação do predicado [short] (linha 30). Em Java, escreve-se [isShort.negate()] e [Predicate.not(String::isEmpty)] para uma referência de método;
  • linhas 32–33: um predicado do tipo [(CharSequence) -> Boolean] é aceito por [filterElements] para filtrar uma lista de [String], embora o parâmetro seja declarado como [(T) -> Boolean] com [T = String]. Isso ocorre porque os tipos funcionais do Kotlin são contravariantes em seus parâmetros e covariantes em seus resultados (Capítulo 4): [(T) -> R] é, na verdade, [Function1<in T, out R>]. Uma função capaz de processar qualquer [CharSequence] também pode processar uma [String]. Em Java, é preciso declarar o parâmetro como [Predicate<? super T>] para obter esse resultado; em Kotlin, isso acontece automaticamente;
  • linhas 36–42 e 73: a extensão [andAlso] retorna uma função que executa duas operações sucessivas sobre o mesmo valor, como o método [andThen] da interface Java [Consumer]. Esta é a maneira mais simples de executar várias operações com uma única chamada. Observe que o lambda [{ this(it); other(it) }] tem duas instruções na mesma linha, separadas por ponto e vírgula;
  • linha 47: a função [compareBy(f)] da biblioteca Kotlin constrói um comparador que compara os valores de [f] (aqui, a idade); [thenBy] especifica o critério de desempate a usar em caso de empate (aqui, o nome). São os equivalentes de [Comparator.comparing] e [thenComparing] em Java. As referências [Person::age] e [Person::name] referem-se às propriedades da data class [Person] (linhas 89–90), para a qual redefinimos o método [toString] a fim de abreviar a saída;
  • linha 49: [reversed] inverte a ordem obtida até então, e [thenByDescending] acrescenta um critério em ordem decrescente;
  • linha 52: [compareBy] também aceita vários critérios, na forma de expressões lambda, aplicados em ordem: aqui, o comprimento do nome, seguido do nome. São dois lambdas passados como argumentos, já que [compareBy] os recebe em um parâmetro declarado como [vararg];
  • linhas 55–56: a função [minOf] retorna o menor de seus dois primeiros parâmetros com base no comparador passado como terceiro parâmetro (em Java: [BinaryOperator.minBy]);
  • linhas 79–86: a função [filterElements] usada nesses testes. Trata-se de uma função de ordem superior que faz o que a função [filter] da biblioteca faz: ela aplica o predicado [predicate] a cada elemento — chamando-o como uma função comum — e mantém os elementos para os quais ele retorna [true].

Essas funções permitem escrever processamentos complexos combinando funções simples, sem escrever uma única classe. Voltaremos a elas ao tratar de coleções e sequências.

7.3.4. Captura de variáveis e closures

Um lambda pode usar as variáveis locais da função em que está escrito. Diz-se que ele captura essas variáveis. Nesse aspecto, o Kotlin difere significativamente do Java. O Java exige que uma variável local capturada seja “efetivamente final”: ela nunca é modificada após sua inicialização, nem no método nem no lambda. O Kotlin, como o C#, o JavaScript ou o Python, não impõe essa restrição: um lambda pode capturar uma variável [var], lê-la mesmo depois de ela ter mudado e até modificá-la. O programa [Lambdas06.kt] demonstra o que essa liberdade permite, como ela é implementada e a armadilha que traz:

package lambdas06

// captura de variáveis e closures

// uma variável de nível superior: as lambdas podem modificá-la
var nbCalls = 0

fun main() {
    // 1 - uma lambda pode usar as variáveis locais que a cercam
    val threshold = 5
    val exceeds: (Int) -> Boolean = { n -> n > threshold }
    println("threshold=$threshold : exceeds(7)=${exceeds(7)}")

    // 2 - em Kotlin, a variável capturada pode ser um var...
    var variableThreshold = 5
    val exceedsVariable: (Int) -> Boolean = { n -> n > variableThreshold }
    println("variableThreshold=$variableThreshold : exceedsVariable(7)=${exceedsVariable(7)}")
    // ... a lambda então vê o valor da variável no momento em que é executada
    variableThreshold = 10
    println("variableThreshold=$variableThreshold : exceedsVariable(7)=${exceedsVariable(7)}")

    // 3 - uma lambda pode modificar uma variável local capturada
    var total = 0
    val accumulate: (Int) -> Unit = { n -> total += n }
    accumulate(3)
    accumulate(4)
    println("total=$total")
    // a variável capturada é armazenada em um objeto Ref, que a lambda mantém
    println("fields of the lambda: ${accumulate::class.java.declaredFields.map { it.type.name }}")
    // uma variável de nível superior (ou uma propriedade) também pode ser modificada
    val count = { nbCalls++ }
    count()
    count()
    println("nbCalls=$nbCalls")

    // 4 - uma closure: a variável capturada sobrevive à função que a criou
    val counterA = createCounter()
    val counterB = createCounter()
    println("A: ${counterA()} ${counterA()} ${counterA()}")
    println("B: ${counterB()} ${counterB()}")

    // 5 - o loop for declara uma nova variável i a cada iteração
    val actions = mutableListOf<() -> Unit>()
    for (i in 0..2) {
        actions.add { print("$i ") }
    }
    print("for: ")
    actions.forEach { it() }
    println()

    // a armadilha: todas as lambdas compartilham o mesmo var
    actions.clear()
    var k = 0
    while (k < 3) {
        actions.add { print("$k ") }
        k++
    }
    print("while, capture of the var k: ")
    actions.forEach { action -> action() }
    println()
}

// uma função que devolve uma função
fun createCounter(): () -> Int {
    // variável local capturada pela lambda devolvida
    var value = 0
    return { ++value }
}

Resultados:

> gradlew -q run -Pmain=lambdas06.Lambdas06Kt
threshold=5 : exceeds(7)=true
variableThreshold=5 : exceedsVariable(7)=true
variableThreshold=10 : exceedsVariable(7)=false
total=7
fields of the lambda: [kotlin.jvm.internal.Ref$IntRef]
nbCalls=2
A: 1 2 3
B: 1 2
for: 0 1 2
while, capture of the var k: 3 3 3

Comentários:

  • Linha 11: o lambda usa a variável local [threshold] declarada na linha 10. [threshold] não é um parâmetro do lambda; é uma variável capturada. Como é um [val], o lambda simplesmente recebe uma cópia de seu valor quando é criado, exatamente como em Java;
  • linhas 15–19: desta vez, o lambda captura um *[var]*, que o Java rejeitaria (*[local variables referenced from a lambda expression must be final or effectively final]). Ele não recebe uma cópia do valor, mas compartilha a variável com a função [main]: quando [variableThreshold] passa a valer 10 (linha 19), o mesmo lambda retorna um resultado diferente (linhas 2–3 dos resultados). A função lambda vê, portanto, o valor da variável no momento em que é executada*, e não no momento em que foi criada. Este é o problema que o Java evita ao proibir essas capturas;
  • Linhas 23–27: o lambda [accumulate] modifica a variável local [total]. Em Java, é preciso usar um objeto mutável ([AtomicInteger], ou o artifício de um array de um único elemento); em Kotlin, escreve-se [total += n] diretamente;
  • linha 29: como isso é possível, já que a própria máquina virtual só permite capturar valores? O compilador Kotlin faz o trabalho que um desenvolvedor Java precisa fazer manualmente: uma variável local [var] capturada e modificada deixa de ser armazenada na pilha e passa a ficar em um pequeno objeto da classe [kotlin.jvm.internal.Ref.IntRef] (há um para cada tipo primitivo, e *[Ref.ObjectRef] para referências), que tem um único campo mutável, *[element]. A função [main] e o lambda compartilham esse objeto: toda leitura ou escrita em [total], em qualquer um dos dois, torna-se uma leitura ou escrita em [total.element]. Podemos verificar isso por meio de reflexão: o único campo do objeto lambda é do tipo [Ref$IntRef] (linha 5 dos resultados). É exatamente o que o compilador C# faz com suas variáveis capturadas;
  • linhas 31–34: um lambda também pode ler e modificar uma variável de nível superior (linha 6) ou uma propriedade do objeto atual. Aqui não há nada a capturar: a variável de nível superior é um campo estático da classe [Lambdas06Kt]; para uma propriedade, o lambda captura a referência [this];
  • linhas 64–67: a função [createCounter] retorna um lambda que captura e modifica sua variável local [value]. Normalmente, uma variável local desaparece quando a função termina. Aqui, a variável é armazenada em um objeto [Ref.IntRef] referenciado pelo lambda: ela sobrevive a [createCounter] enquanto o lambda existir. A combinação do lambda com as variáveis que ele captura é chamada de “closure”;
  • linhas 37–40: cada chamada a *[createCounter] cria uma nova variável [value]* e, portanto, um novo contador, independente dos outros. Os resultados (linhas 7–8) confirmam isso;
  • linhas 44–48: em um laço [for] do Kotlin, a variável [i] é um [val], novo a cada iteração: cada lambda captura o seu, e os três lambdas imprimem 0, 1 e 2. Observe que uma lista de funções é executada por meio de [actions.forEach { it() }]: [it] é uma função que é chamada;
  • Linhas 53–59: este é o lado negativo da flexibilidade do Kotlin. O laço [while] usa uma única variável, [k], que é modificada a cada iteração. Os três lambdas capturam a mesma variável e imprimem seu valor quando são executados — isto é, após o laço, quando ela é igual a 3: todos imprimem 3 (linha 10 dos resultados). O Java elimina essa armadilha em tempo de compilação; em Kotlin, cabe ao desenvolvedor lidar com ela. A solução é a mesma do Java: declarar um novo [val] no corpo do laço a cada iteração ([val copy = k]) e capturá-lo ou, melhor ainda, usar um laço [for].

A regra do Java tem uma justificativa sólida: um lambda pode ser executado mais tarde, ou em outra thread (Capítulo 8). Se ele pode modificar as variáveis locais de uma função, ou lê-las enquanto outra thread as modifica, isso pode levar a um comportamento imprevisível. O Kotlin adota uma abordagem diferente, mais prática: capturar [var] é permitido, mas os objetos [Ref] não são protegidos contra acesso concorrente. Portanto, lembremos que capturar um [var] é seguro em um programa de thread única e em lambdas executados imediatamente ([forEach], [filter]…), mas que, assim que um lambda puder ser executado em outra thread, o estado mutável compartilhado deve ser explicitado por meio de um objeto cujo comportamento em relação às threads seja escolhido explicitamente ([AtomicInteger], coleção concorrente…). Voltaremos a esse assunto nos Capítulos 8 e 9. As funções [inline], apresentadas mais adiante, também evitam a criação de objetos [Ref] quando o lambda é copiado para o código chamador.

7.4. Funções inline e funções de escopo

7.4.1. Funções inline

Um lambda é um objeto. Passar um lambda a uma função de ordem superior implica, portanto, um custo: a criação do objeto (exceto no caso de um lambda que não captura nada, que a máquina virtual pode reutilizar), a chamada ao seu método [invoke] , as conversões [Int] ↔ [Integer] impostas pelas interfaces genéricas [Function1], [Function2]… e os objetos [Ref] das variáveis capturadas. Para uma função como [filter], chamada em cada elemento de coleções que às vezes podem ser muito grandes, esse custo importa. O Kotlin o elimina com o modificador [inline]: quando uma função é declarada [inline fun], o compilador não gera uma chamada a essa função; em vez disso, ele copia seu código para cada local em que ela é chamada e também copia o código dos lambdas passados a ela. Como resultado, não há mais objetos lambda, nem chamadas a [invoke], nem conversões. As funções da biblioteca padrão que aceitam lambdas ([forEach], [filter], [map], [fold], [let], [apply], [repeat], [use], [synchronized]…) são quase todas [inline]. O Java não tem equivalente: ele conta com o compilador just-in-time da máquina virtual para produzir um resultado comparável em tempo de execução.

A inserção do código tem uma segunda consequência, mais perceptível: como o código do lambda é copiado para a função chamadora, uma instrução [return] sem rótulo pode sair da função chamadora a partir dali. Este é o retorno não local encontrado com *[forEach] em *[Lambdas03.kt]. Dois modificadores complementam *[inline]*:

  • [noinline], aplicado a um parâmetro de função de uma função [inline], especifica que o lambda correspondente não deve ser copiado, mas passado como um objeto comum. Isso é necessário quando a função quer reter o lambda (armazená-lo em uma lista, retorná-lo como resultado etc.): um código copiado não pode ser armazenado em uma lista;
  • [crossinline] exige que o lambda seja copiado, mas proíbe retornos não locais. Isso é necessário quando a função [inline] não executa o lambda ela mesma, mas o executa em outro contexto — por exemplo, dentro de um objeto [Runnable] que ela cria: quando o [Runnable] for executado, a função chamadora pode já ter terminado há muito tempo, e um [return] não poderia mais sair dela.

O programa [Lambdas07.kt] ilustra esses conceitos (este programa não tem equivalente no curso de Java):

package lambdas07

// funções inline, noinline, crossinline

fun main() {
    // 1 - uma função comum recebe um objeto função; uma função inline recebe o código da lambda
    execute { println("lambda passed to execute, executed by: ${currentMethod()}") }
    executeInline { println("lambda passed to executeInline, executed by: ${currentMethod()}") }

    // 2 - o return não local só é permitido em uma lambda passada a uma função inline
    val numbers = listOf(3, 8, 1, 6)
    println("first even of $numbers: ${firstEven(numbers)}")

    // 3 - noinline: uma lambda que deve ser mantida como objeto
    val callbacks = mutableListOf<() -> Unit>()
    executeThenStore(callbacks, { println("executed right away") }, { println("stored callback") })
    println("${callbacks.size} stored callback, which we execute:")
    callbacks.forEach { it() }

    // 4 - crossinline: uma lambda executada em outro contexto
    val task = asTask { println("executed by ${Thread.currentThread().name}") }
    val thread = Thread(task, "worker")
    thread.start()
    thread.join()
}

// o nome do método que chama currentMethod (lido da pilha de chamadas)
fun currentMethod(): String = Throwable().stackTrace[1].methodName

// uma função comum: block é um objeto do tipo () -> Unit
fun execute(block: () -> Unit) {
    block()
}

// uma função inline: seu código, e o da lambda, são copiados onde ela é chamada
inline fun executeInline(block: () -> Unit) {
    block()
}

// nosso próprio forEach, inline como o da biblioteca
inline fun <T> forEachElement(elements: List<T>, action: (T) -> Unit) {
    for (element in elements) action(element)
}

fun firstEven(numbers: List<Int>): Int? {
    forEachElement(numbers) {
        // return não local: saímos de firstEven, e não apenas da lambda
        if (it % 2 == 0) return it
    }
    return null
}

// immediate é copiado; stored continua sendo um objeto função, que pode ser colocado na lista
inline fun executeThenStore(
    callbacks: MutableList<() -> Unit>,
    immediate: () -> Unit,
    noinline stored: () -> Unit,
) {
    immediate()
    callbacks.add(stored)
}

// action é executado em um objeto Runnable, não em asTask: um return não local é impossível ali
inline fun asTask(crossinline action: () -> Unit): Runnable = Runnable { action() }

Resultados:

1
2
3
4
5
6
7
8
> gradlew -q run -Pmain=lambdas07.Lambdas07Kt
lambda passed to execute, executed by: main$lambda$0
lambda passed to executeInline, executed by: main
first even of [3, 8, 1, 6]: 8
executed right away
1 stored callback, which we execute:
stored callback
executed by worker

Comentários:

  • Linha 28: a função [currentMethod] retorna o nome do método que a chamou. Para isso, ela cria um objeto [Throwable], que salva a pilha de execução no momento de sua criação, e lê o segundo elemento dessa pilha (o primeiro é [currentMethod] em si). Usamos isso para determinar onde o código de um lambda é executado;
  • linhas 31–36: duas funções idênticas, uma comum e a outra declarada como [inline];
  • linha 7: o lambda é passado à função comum [execute]. O compilador transforma isso no corpo de um método privado da classe [Lambdas07Kt] — chamado [main$lambda$0] aqui — e cria um objeto do tipo [() -> Unit] que o chama. É de fato [main$lambda$0] que é executado (linha 1 dos resultados);
  • linha 8: o lambda é passado à função [inline] [executeInline]. O compilador copiou o corpo de [executeInline] e o do lambda para [main]: o [println] do lambda é executado diretamente dentro do método [main] (linha 2 dos resultados). Nenhum objeto função foi criado;
  • linhas 41–50: [forEachElement] é nossa própria versão de [forEach], [inline], como a original. Em [firstEven], a instrução [return it] no lambda é um retorno não local: ela sai da função [firstEven] retornando o primeiro número par encontrado (linha 3 dos resultados), e o laço termina ali. Com uma função comum como [execute], o compilador rejeitaria tal [return] (['return' is prohibited here]): o lambda seria um objeto separado, que poderia ser executado depois que [firstEven] tivesse terminado;
  • linhas 54–60: uma função [inline] que recebe dois lambdas: ela executa o primeiro e armazena o segundo em uma lista para execução posterior. O segundo parâmetro deve ser declarado como [noinline]: sem esse modificador, o compilador se recusa a armazenar o lambda na lista ([illegal usage of inline parameter 'stored: () -> Unit'. Add 'noinline' modifier to the parameter declaration.]). As linhas 16–18 a utilizam (linhas 4–6 da saída);
  • linha 64: a função [asTask] cria um objeto [Runnable] (conversão SAM) que executará o lambda [action]. O parâmetro deve ser declarado como [crossinline]: sem esse modificador, o compilador o rejeita ([cannot inline 'action: () -> Unit' here: it might contain non-local returns. Add 'crossinline' modifier to parameter declaration 'action: () -> Unit'.]). As linhas 21–24 executam o [Runnable] obtido em uma thread chamada [worker] (as threads são tratadas no Capítulo 8), como confirma a linha 7 dos resultados.

Você não deve usar [inline] em qualquer função: o modificador só é útil para funções que aceitam parâmetros funcionais e aumenta o tamanho do código gerado (o compilador, aliás, emite um aviso para uma função [inline] sem parâmetros funcionais). Por fim, ele tem um terceiro uso, discutido no Capítulo 4: somente funções [inline] podem ter parâmetros de tipo [reified] ([inline fun <reified T> …]), cujo tipo permanece conhecido em tempo de execução, já que o código é copiado para o local em que esse tipo é conhecido.

7.4.2. Funções de escopo

A biblioteca padrão do Kotlin fornece cinco pequenas funções muito usadas — [inline] — conhecidas como "funções de escopo": [let], [run], [with], [apply] e [also]. Elas quase não fazem nada: cada uma executa um lambda sobre um objeto. Elas diferem em dois aspectos:

  • a maneira como o lambda se refere ao objeto: como seu parâmetro [it] (o lambda é do tipo [(T) -> R]) ou como seu receptor [this], que pode então ser omitido (o lambda é um lambda com receptor, do tipo [T.() -> R]; veja [Lambdas01.kt]);
  • que é o que a função retorna: o resultado da lambda ou o próprio objeto.
Função
Objeto designado por
Retorna
Uso típico
[let]
[it]
o resultado da lambda
transformar um valor; com [?.let], processar um valor não nulo
[run]
[this]
o resultado da lambda
Calcular um resultado com base nas propriedades do objeto
[with(object)]
[this]
o resultado da lambda
como [run], em que o objeto é passado como parâmetro
[apply]
[this]
o objeto
Configurar um objeto recém-criado
[also]
[it]
o objeto
Processamento adicional (log, cache etc.) sem modificar a cadeia de chamadas

O programa [Lambdas08.kt] as utiliza (não há equivalente no curso de Java):

package lambdas08

// as funções de escopo: let, run, with, apply, also (e takeIf)

fun main() {
    // 1 - apply: configura o objeto (this) e devolve o objeto
    val paul = Person("Paul").apply {
        age = 32
        city = "Angers"
    }
    println("apply: $paul")

    // 2 - also: um processamento adicional do objeto (it), que é devolvido
    val persons = mutableListOf<Person>()
    val melanie = Person("Mélanie", 25).also { persons.add(it) }
    println("also: $melanie, persons=$persons")

    // 3 - let: transforma o objeto (it) em um resultado; muito usado com ?.
    val length = paul.name.let { it.length * 2 }
    println("let: length=$length")
    for (city in listOf("Tours", null)) {
        val message = city?.let { "lives in ${it.uppercase()}" } ?: "unknown city"
        println("let and ?.: $message")
    }

    // 4 - run: um cálculo sobre o objeto (this), que devolve um resultado
    val description = paul.run { "$name, $age years old, lives in $city" }
    println("run: $description")

    // 5 - with: como run, mas o objeto é passado como parâmetro
    val summary = with(StringBuilder()) {
        append("Persons: ")
        append(persons.joinToString { it.name })
        toString()
    }
    println("with: $summary")

    // 6 - takeIf: o objeto se satisfizer o predicado, null caso contrário
    for (age in listOf(15, 40)) {
        val adult = Person("Jo", age).takeIf { it.age >= 18 }
        println("takeIf: ${adult ?: "minor"}")
    }
}

class Person(val name: String, var age: Int = 0) {
    var city: String? = null

    override fun toString() = "Person(name=$name, age=$age, city=$city)"
}

Resultados:

> gradlew -q run -Pmain=lambdas08.Lambdas08Kt
apply: Person(name=Paul, age=32, city=Angers)
also: Person(name=Mélanie, age=25, city=null), persons=[Person(name=Mélanie, age=25, city=null)]
let: length=8
let and ?.: lives in TOURS
let and ?.: unknown city
run: Paul, 32 years old, lives in Angers
with: Persons: Mélanie
takeIf: minor
takeIf: Person(name=Jo, age=40, city=null)

Comentários:

  • linhas 45–48: uma classe [Person] comum, com propriedades mutáveis;
  • linhas 7–9: [apply] executa a lambda com o objeto como receptor: dentro da lambda, [age = 32] equivale a [this.age = 32]. Em seguida, ela retorna o objeto, que é atribuído a [paul]. Isso cria e configura um objeto em uma única expressão. Sua assinatura ilustra o mecanismo: [inline fun <T> T.apply(block: T.() -> Unit): T];
  • linha 15: [also] executa a lambda com o objeto como parâmetro [it] e depois retorna o objeto. É usada para obter um efeito colateral (neste caso, adicionar a uma lista) sem precisar introduzir uma variável intermediária;
  • linha 19: [let] executa a lambda com o objeto como parâmetro [it] e retorna o resultado da lambda: trata-se de uma transformação;
  • Linhas 21–23: o uso mais comum de [let], como visto no Capítulo 3: [city?.let { … }] executa a lambda somente se [city] não for [null] e, dentro da lambda, [it] é do tipo [String] e não [String?]. Se [city] for igual a [null], a expressão é igual a [null], e o operador Elvis [?:] fornece o valor padrão;
  • Linha 27: [run] executa a lambda com o objeto como receptor e retorna o resultado da lambda: ela usa diretamente as propriedades [name], [age] e [city] de [paul];
  • Linhas 31–34: [with] faz o mesmo que [run], mas o objeto lhe é passado como primeiro parâmetro, e a lambda vem em segundo, fora dos parênteses. Todos os métodos chamados dentro da lambda ([append], [toString]) são os de [StringBuilder]. A função [buildString] do Capítulo 5 é construída sobre esse modelo;
  • linhas 39–41: [takeIf] não é uma função de escopo, mas é usada da mesma forma: ela retorna o objeto se ele satisfizer o predicado e [null] caso contrário. Combina-se naturalmente com [?:], [?.let]… ([takeUnless] faz o oposto).

Essas funções tornam o código mais compacto, mas não devem ser usadas em excesso: várias funções de escopo aninhadas, cada uma com seu próprio [it] ou [this], tornam rapidamente o código ilegível. Uma variável local bem nomeada costuma ser preferível.

7.5. Tipos funcionais, interfaces funcionais ou interfaces?

Em muitas linguagens, o conceito de "função passada como parâmetro" (ponteiro de função em C, delegate em C#) é distinto do conceito de interface, e podemos nos perguntar qual escolher. Em Java, a questão se coloca de outra forma, já que os dois conceitos são um só: uma lambda é uma instância de uma interface. Kotlin fica em um meio-termo: ela tem tipos funcionais, que se distinguem das interfaces na sintaxe, mas são interfaces para a máquina virtual; e tem interfaces funcionais ([fun interface]) que podem ser implementadas por meio de lambdas. Vejamos o exemplo [Lambdas09.kt], semelhante a [Lambdas02.kt]:

package lambdas09

// um parâmetro de tipo função

fun main() {
    // execução da função add
    println(execute(2, 3, ::add))
    // execução da função subtract
    println(execute(2, 3, ::subtract))
    // execução de um método de biblioteca Java com a forma adequada
    println(execute(2, 3, Math::max))
    // execução de uma lambda: não é necessária uma função nomeada
    println(execute(2, 3) { n1, n2 -> n1 * n2 })
}

// execução de uma operação recebida como parâmetro
// (por último, para que uma lambda possa ser passada fora dos parênteses)
fun execute(n1: Int, n2: Int, op: (Int, Int) -> Int): Int = op(n1, n2)

// duas funções com a forma (Int, Int) -> Int
fun add(n1: Int, n2: Int): Int {
    println("add($n1,$n2)")
    return n1 + n2
}

fun subtract(n1: Int, n2: Int): Int {
    println("subtract($n1,$n2)")
    return n1 - n2
}

Resultados:

1
2
3
4
5
6
7
> gradlew -q run -Pmain=lambdas09.Lambdas09Kt
add(2,3)
5
subtract(2,3)
-1
3
6

Na linha 18, a função [execute] espera um parâmetro do tipo [(Int, Int) -> Int]. Isso permite passar-lhe funções diferentes: nossas funções de nível superior [add] e [subtract] (linhas 7 e 9), e um método da biblioteca Java com a forma correta (linha 11: entre as sobrecargas de [Math.max]*, o compilador escolhe [int max(int a, int b)]***, que Kotlin enxerga como ***[max(a: Int, b: Int): Int]***), e até uma lambda (linha 13): não foi necessário escrever uma função de multiplicação. O parâmetro de função foi colocado por último** para que a lambda possa ser escrita fora dos parênteses: essa é a convenção em toda a biblioteca Kotlin, e é uma boa ideia segui-la em suas próprias funções.

Com [fun interface], vemos o polimorfismo de interface abordado no Capítulo 4: o programa [Lambdas10.kt] demonstra isso implementando a mesma interface com classes:

package lambdas10

// classes que implementam uma interface funcional ou um tipo de função

fun main() {
    // execução da operação Add
    println(execute(Add(), 2, 3))
    // execução da operação Subtract
    println(execute(Subtract(), 2, 3))
    // a mesma função execute ainda aceita lambdas
    println(execute({ n1, n2 -> n1 * n2 }, 2, 3))
    // uma interface com dois métodos abstratos não aceita mais uma lambda: é necessária uma classe
    val division = object : NamedOperation {
        override fun calculate(n1: Int, n2: Int) = n1 / n2

        override val name = "integer division"
    }
    println("${division.name}: ${division.calculate(7, 2)}")
    // uma classe também pode implementar um tipo de função
    val modulo = Modulo()
    println("modulo(7, 2)=${modulo(7, 2)}, applyFunction(modulo)=${applyFunction(modulo, 7, 3)}")
}

// execução do único método da interface Operation
fun execute(op: Operation, n1: Int, n2: Int): Int = op.calculate(n1, n2)

// execução de uma função do tipo (Int, Int) -> Int
fun applyFunction(f: (Int, Int) -> Int, n1: Int, n2: Int): Int = f(n1, n2)

// a interface funcional Operation
fun interface Operation {
    fun calculate(n1: Int, n2: Int): Int
}

// uma interface que não é funcional: um método abstrato e uma propriedade abstrata
interface NamedOperation : Operation {
    val name: String
}

// classe Add
class Add : Operation {
    override fun calculate(n1: Int, n2: Int): Int {
        println("Add($n1,$n2)")
        return n1 + n2
    }
}

// classe Subtract
class Subtract : Operation {
    override fun calculate(n1: Int, n2: Int): Int {
        println("Subtract($n1,$n2)")
        return n1 - n2
    }
}

// uma classe que implementa o tipo de função (Int, Int) -> Int
class Modulo : (Int, Int) -> Int {
    override fun invoke(n1: Int, n2: Int): Int = n1 % n2
}

Resultados:

1
2
3
4
5
6
7
8
> gradlew -q run -Pmain=lambdas10.Lambdas10Kt
Add(2,3)
5
Subtract(2,3)
-1
6
integer division: 3
modulo(7, 2)=1, applyFunction(modulo)=1

Comentários:

  • linhas 31–32: a interface funcional [Operation] define um método [calculate];
  • linhas 41–49: as classes [Add] e [Subtract] implementam a interface [Operation];
  • linha 25: a função [execute], cujo primeiro parâmetro é do tipo definido pela interface [Operation]. Ela recebe, em sequência, uma instância da classe [Add], uma instância da classe [Subtract] (linhas 7 e 9) e, depois, uma lambda (linha 11). Para a lambda, a conversão de SAM para *[Operation] é feita automaticamente, já que se trata de um argumento de chamada. Para [execute], esses três objetos são do mesmo tipo: objetos que implementam [Operation]*;
  • Linhas 36–37: a interface [NamedOperation] herda o método [calculate] e adiciona uma propriedade abstrata [name]. Ela não é funcional (na verdade, não pode ser declarada como [fun interface]): não pode mais ser implementada por meio de uma lambda; é necessária uma classe — neste caso, um objeto anônimo (linhas 13–16);
  • linhas 57–58: o inverso também é verdadeiro: uma classe pode implementar um tipo funcional, já que ele é uma interface. Suas instâncias são então chamadas como funções ([modulo(7, 2)]) e passadas onde quer que se espere uma função ([applyFunction(modulo, 7, 3)], linha 21).

Esses dois exemplos mostram que, em Kotlin, assim como em Java, uma função que espera um comportamento aceita objetos de classes escritas para esse fim, referências e lambdas. Restam duas questões. A primeira é específica de Kotlin: para um parâmetro funcional, é necessário um tipo funcional ou basta uma [fun interface]?

  • O tipo funcional é a escolha padrão. Ele não exige declaração, é chamado como uma função, aceita diretamente lambdas e referências e se beneficia das funções [inline]. Um [typealias] lhe dá um nome quando ele é longo;
  • a interface "fun" se justifica quando se quer um tipo realmente distinto (que não possa ser confundido com outra função da mesma forma), um método com nome descritivo, métodos adicionais com corpo ou uma API também destinada a chamadores Java: para Java, uma [fun interface] é uma interface funcional comum, utilizável com suas lambdas, ao passo que um tipo funcional de Kotlin aparece para ele como uma [Function2<Integer, Integer, Integer>] cujo método [invoke] deve retornar um objeto ([Unit] para uma função "sem retorno").

A segunda questão é a mesma de Java: a interface deve ter um único método ou vários?

  • Uma função, um tipo funcional ou uma interface de método único é mais flexível de usar: qualquer função existente com a forma correta serve, e uma lambda permite até escrever a função no próprio local da chamada. Não há classe a escrever. Essa flexibilidade explica por que as bibliotecas modernas (coleções, as corrotinas do Capítulo 9, Spring) fazem amplo uso de parâmetros funcionais;
  • uma interface com vários membros volta a levar vantagem assim que o comportamento a implementar envolve várias operações inter-relacionadas ([calculate] e [name] acima), ou quando exige estado e identidade próprios.

É o caso da interface [ITaxDao] na camada [dao] do Capítulo 6: embora tenha apenas um membro — a propriedade [val taxBrackets: List<TaxBracket>] —, suas implementações têm estado (as faixas lidas, o nome do arquivo), são criadas pelo contêiner de injeção de dependência e representam um papel claramente nomeado dentro da aplicação. Um [() -> List<TaxBracket>] teria bastado tecnicamente, mas seria muito menos descritivo. Reservamos, portanto, os tipos funcionais para comportamentos curtos e pontuais (um critério, uma transformação, uma ação) e as interfaces "de negócio" para os papéis da aplicação, independentemente do número de seus membros.

7.6. Tratamento de eventos

7.6.1. O padrão Observer

As funções passadas como parâmetros servem para implementar eventos. Como Java, Kotlin não tem uma palavra-chave dedicada a eventos (C# tem a sua, [event]): ela usa as convenções estabelecidas por Java já na versão 1.1 para componentes gráficos e JavaBeans, conhecidas como "modelo de listeners". Uma classe [C1] que queira sinalizar um evento [Xxx] procede da seguinte forma:

  • Uma classe [XxxEvent] encapsula as informações sobre o evento, incluindo o objeto que o disparou, chamado de origem. Em Java, a convenção é que ela derive de [java.util.EventObject], que armazena a origem; em Kotlin, basta uma classe comum com propriedades somente leitura, e é isso que faremos;
  • Um tipo de listener define a forma da função que será chamada quando o evento ocorrer. Em Java, é uma interface chamada [XxxListener]; em Kotlin, é na maioria das vezes um simples tipo funcional, [(XxxEvent) -> Unit], nomeado por um [typealias]: um listener será uma lambda ou uma referência de função;
  • a classe [C1] gerencia uma lista de funções e oferece dois métodos públicos para registrar e cancelar o registro nela: [addXxxListener(listener)] e [removeXxxListener(listener)];
  • Quando uma instância [c1] de [C1] quer sinalizar o evento, ela cria um objeto [XxxEvent] e chama cada um dos listeners registrados, passando-lhes esse objeto. Por convenção, essa notificação é feita por um método protegido [fireXxx(e: XxxEvent)] ("disparar", do inglês "fire"), que uma classe derivada pode sobrescrever para modificar a forma como o evento é publicado;
  • Se um objeto [c2] quer ser notificado do evento [Xxx] do objeto [c1], ele se inscreve usando [c1.addXxxListener(...)]. Pode cancelar a inscrição por meio de [c1.removeXxxListener(...)] quando não quiser mais ser notificado. Como [c1] gerencia uma lista, diferentes objetos podem se inscrever para ser notificados do mesmo evento.

Nesse cenário, temos:

  • uma classe que sinaliza (também se diz "publica" ou "emite") um evento;
  • objetos que são notificados desse evento. Diz-se que eles se inscrevem ou se registram no evento: são os listeners, ou manipuladores de eventos;
  • um tipo de listener que define a forma das funções que serão notificadas do evento.

Esse é o padrão de projeto Observer: o emissor não conhece seus assinantes; ele apenas os notifica. Esse modelo oferece a mesma proteção que uma palavra-chave dedicada: a lista de listeners é uma propriedade privada do emissor. Do lado de fora, só é possível se inscrever ou cancelar a inscrição; não é possível esvaziar a lista, substituir outros listeners nem disparar o evento no lugar do emissor.

7.6.2. Um exemplo: temperatura excessivamente alta

Considere o exemplo a seguir:

  • Uma classe chamada [Emitter] encapsula uma temperatura. Quando essa temperatura ultrapassa um certo limite, um evento deve ser disparado. Chamaremos esse evento de [TemperatureTooHigh]. As informações sobre esse evento serão encapsuladas em um objeto [TemperatureTooHighEvent], e os listeners serão funções do tipo [TemperatureTooHighListener];
  • uma classe chamada [Subscriber] se registra como listener do evento anterior. Quando é notificada do evento, exibe uma mensagem no console. Um listener cancela a própria inscrição automaticamente depois de receber um número determinado de alertas;
  • Um programa de console cria um emissor e dois assinantes. Ele lê temperaturas pelo teclado e as registra no emissor. Se alguma delas for alta demais, o emissor sinaliza o evento [TemperatureTooHigh].

Este programa é dividido em três arquivos no pacote [lambdas11]. Primeiro, o arquivo [Emitter.kt], que contém a classe do evento, o tipo do listener e a classe [Emitter]:

package lambdas11

import java.time.LocalTime
import java.util.concurrent.CopyOnWriteArrayList

// as informações transportadas pelo evento
class TemperatureTooHighEvent(
    // o emissor que originou o evento
    val source: Emitter,
    // temperatura no momento do evento
    val temperature: Double,
) {
    // hora do evento
    val time: LocalTime = LocalTime.now()
}

// a forma dos listeners de evento: um tipo de função simples
typealias TemperatureTooHighListener = (TemperatureTooHighEvent) -> Unit

// a classe que sinaliza o evento
open class Emitter(val name: String) {
    companion object {
        // limite que dispara o evento
        const val THRESHOLD = 19.0
    }

    // os listeners registrados: uma lista de funções
    private val listeners = CopyOnWriteArrayList<TemperatureTooHighListener>()

    // temperatura observada: escrever a propriedade pode disparar o evento
    var temperature = 0.0
        set(value) {
            field = value
            if (value > THRESHOLD) {
                // o evento é sinalizado aos listeners
                fireTemperatureTooHigh(TemperatureTooHighEvent(this, value))
            }
        }

    // registro de um listener
    fun addTemperatureTooHighListener(listener: TemperatureTooHighListener) {
        listeners.add(listener)
    }

    // cancelamento do registro de um listener
    fun removeTemperatureTooHighListener(listener: TemperatureTooHighListener) {
        listeners.remove(listener)
    }

    // notificação do evento a todos os listeners registrados
    protected open fun fireTemperatureTooHigh(e: TemperatureTooHighEvent) {
        for (listener in listeners) {
            listener(e)
        }
    }
}

Comentários:

  • Linhas 7–14: a classe [TemperatureTooHighEvent] armazena a origem do evento, do tipo [Emitter], e a temperatura que o disparou. Acrescentamos o horário do evento, [time], que é inicializado quando o objeto é criado. Todas as propriedades são do tipo [val]: um listener não deve poder modificar as informações do evento para os listeners seguintes. Não derivamos a classe de [EventObject] como em Java: isso não teria utilidade aqui e nos obrigaria — para que a origem seja do tipo [Emitter] em vez de [Any] — a redefinir o método [getSource];
  • Linha 18: o tipo do listener. Um listener é uma função que recebe o objeto do evento como argumento e não retorna nada. Onde Java exige uma interface *[TemperatureTooHighListener]* derivada de *[EventListener]*, Kotlin usa simplesmente um alias de tipo funcional. Poderíamos igualmente ter declarado uma ***[fun interface TemperatureTooHighListener]***: essa seria a escolha certa se os listeners fossem escritos em Java;
  • linha 24: o limite de temperatura acima do qual o evento [TemperatureTooHigh] é disparado, uma constante do objeto companheiro;
  • linha 21: o emissor tem um nome para identificação. A classe é declarada como [open], para que uma classe derivada possa redefinir o método [fireTemperatureTooHigh];
  • linha 28: a lista de listeners registrados, uma lista de funções. É uma [CopyOnWriteArrayList] do pacote [java.util.concurrent], uma lista que, sempre que é modificada, copia seu conteúdo para um novo array. Uma iteração em andamento continua, portanto, no array antigo, mesmo que a lista seja modificada nesse meio-tempo. Veremos adiante por que isso é essencial aqui. Essa lista é o tipo padrão para listas de listeners: a lista é percorrida a cada evento, mas raramente é modificada;
  • Linhas 31–36: a propriedade [temperature] tem um acessor personalizado [set] (Capítulo 4): ele armazena o novo valor no campo oculto [field] e, em seguida, sinaliza o evento se o valor ultrapassar o limite. A publicação é feita pelo método [fireTemperatureTooHigh], ao qual é passado um objeto [TemperatureTooHighEvent]; esse objeto se origina do próprio emissor ([this]) e contém a temperatura que ultrapassou o limite. Onde Java exige um método chamado [setTemperature], o usuário da classe simplesmente escreve [e1.temperature = 21.0];
  • linhas 41–42: registrar um listener o adiciona à lista. O tipo do parâmetro não aceita nulo: o compilador rejeita qualquer listener do tipo [null], o que Java precisa rejeitar em tempo de execução por meio de [Objects.requireNonNull];
  • linhas 46–47: cancelar o registro remove o listener da lista. O método [remove] procura o objeto a ser removido usando [equals]: portanto, é preciso passar-lhe um objeto idêntico ao que foi registrado;
  • linhas 51–53: a notificação chama cada listener registrado, na ordem em que foram registrados, como uma função: [listener(e)]. Se não houver listeners, o laço não faz nada: não há casos especiais a tratar.

Aqui está o arquivo [Subscriber.kt]:

package lambdas11

// uma classe que se registra como listener do evento
class Subscriber(
    // nome do assinante
    private val name: String,
    // número máximo de alertas aceitos
    private val nbMaxAlerts: Int,
) {
    // número de alertas recebidos
    private var nbAlerts = 0

    // registro em um emissor
    fun subscribe(emitter: Emitter) {
        emitter.addTemperatureTooHighListener(::onTemperatureTooHigh)
    }

    // cancelamento do registro: uma nova referência ao mesmo método do mesmo objeto é igual a ele
    fun unsubscribe(emitter: Emitter) {
        emitter.removeTemperatureTooHighListener(::onTemperatureTooHigh)
    }

    // handler do evento TemperatureTooHigh
    private fun onTemperatureTooHigh(e: TemperatureTooHighEvent) {
        val emitter = e.source
        val temperature = "%.1f".format(e.temperature)
        println("Subscriber [$name]: the source [${emitter.name}] " +
            "signaled a temperature that is too high: [$temperature]")
        // além de nbMaxAlerts alertas, o assinante cancela seu registro
        nbAlerts++
        if (nbAlerts == nbMaxAlerts) {
            unsubscribe(emitter)
            println("Subscriber [$name]: unsubscribed after $nbAlerts alert(s)")
        }
    }
}

Comentários:

  • linhas 4–11: cada assinante é identificado por um nome e recebe o número máximo de alertas que aceita ([nbMaxAlerts]). Ele conta os alertas recebidos ([nbAlerts]);
  • linhas 14–15: registro em um emissor. O listener é uma referência vinculada, [::onTemperatureTooHigh], ou seja, [this::onTemperatureTooHigh]: o método deste assinante, [onTemperatureTooHigh];
  • linhas 19–20: o cancelamento da inscrição passa uma nova referência, [::onTemperatureTooHigh], a [removeTemperatureTooHighListener]. Em Java, isso seria um erro clássico: duas avaliações de [this::onTemperatureTooHigh] produzem dois objetos que [equals]* considera diferentes, e o cancelamento não removeria nada, sem nenhuma mensagem de erro; o listener deve ser criado uma única vez e armazenado em um campo. Vimos com [Lambdas04.kt] que, em Kotlin, duas referências à mesma função do mesmo objeto são iguais: [remove] encontra, portanto, o listener registrado — e somente esse listener —, já que as referências dos outros assinantes estão vinculadas a outros objetos. Isso não aconteceria com uma lambda: [{ e -> onTemperatureTooHigh(e) }]*, escrita duas vezes, resultaria em dois objetos diferentes;
  • Linha 24: o manipulador de eventos. Ele tem a forma ditada pelo tipo [TemperatureTooHighListener]. É privado: somente o assinante pode registrá-lo em um emissor. Outra abordagem é fazer com que o tipo de listener seja implementado pela própria classe [Subscriber] ([class Subscriber : TemperatureTooHighListener], com um método [invoke]) e se registrar com [this]. Essa abordagem tem o inconveniente de tornar o método [invoke] público, e qualquer um poderia então chamá-lo;
  • linha 25: a origem do evento é diretamente do tipo [Emitter];
  • linhas 26–28: o manipulador exibe o nome do assinante, o nome do emissor que informou o evento e a temperatura que o disparou. O formato [%.1f] exibe o número real com uma casa decimal, segundo as convenções locais da máquina (a função Kotlin [format] as utiliza; aqui, um ponto decimal). A string é escrita em duas partes concatenadas por [+] para que a linha caiba na página;
  • linhas 30–33: após [nbMaxAlerts] alertas, o assinante cancela sua inscrição no emissor. Ele faz isso durante a notificação do evento, a partir do seu próprio manipulador — ou seja, enquanto o método [fireTemperatureTooHigh] percorre a lista de listeners. Isso é seguro graças a [CopyOnWriteArrayList]: [remove] cria um novo array, mas a iteração em andamento continua no antigo.

Por fim, aqui está o programa principal, [Lambdas11.kt]:

package lambdas11

// tratamento de eventos: um emissor e listeners

fun main() {
    // criação de um emissor de eventos
    val e1 = Emitter("e")
    // criação de dois assinantes que se registram em e1
    val subscribers = listOf(Subscriber("s0", 3), Subscriber("s1", 1))
    for (subscriber in subscribers) {
        subscriber.subscribe(e1)
    }
    // um terceiro listener: uma lambda
    e1.addTemperatureTooHighListener { e ->
        println("Log: %.1f °C at %tT".format(e.temperature, e.time))
    }

    // as temperaturas são lidas do teclado
    while (true) {
        print("Temperature (nothing to stop): ")
        // fim da entrada? (readlnOrNull devolve null se a entrada padrão estiver fechada)
        val input = readlnOrNull()
        if (input.isNullOrBlank()) {
            break
        }
        // a vírgula decimal é aceita
        val temperature = input.trim().replace(',', '.').toDoubleOrNull()
        if (temperature == null) {
            // o erro é sinalizado
            println("Incorrect temperature")
        } else {
            // temperatura correta - ela é armazenada no emissor
            e1.temperature = temperature
        }
    }
}

Resultados (a entrada padrão foi fornecida por redirecionamento; reinserimos as entradas após os prompts, no ponto em que o programa as lê):

> gradlew -q run -Pmain=lambdas11.Lambdas11Kt
Temperature (nothing to stop): 17
Temperature (nothing to stop): 21
Subscriber [s0]: the source [e] signaled a temperature that is too high: [21.0]
Subscriber [s1]: the source [e] signaled a temperature that is too high: [21.0]
Subscriber [s1]: unsubscribed after 1 alert(s)
Log: 21.0 °C at 12:33:37
Temperature (nothing to stop): abc
Incorrect temperature
Temperature (nothing to stop): 22,5
Subscriber [s0]: the source [e] signaled a temperature that is too high: [22.5]
Log: 22.5 °C at 12:33:37
Temperature (nothing to stop): 25
Subscriber [s0]: the source [e] signaled a temperature that is too high: [25.0]
Subscriber [s0]: unsubscribed after 3 alert(s)
Log: 25.0 °C at 12:33:37
Temperature (nothing to stop): 30
Log: 30.0 °C at 12:33:37
Temperature (nothing to stop):

Comentários:

  • linha 7: criação do emissor;
  • linhas 9–11: criação de dois assinantes, [s0] (até 3 alertas) e [s1] (1 alerta), que são registrados no emissor;
  • linhas 14–15: um terceiro listener, uma lambda passada fora dos parênteses, que funciona como log. O tipo do parâmetro [e] é inferido a partir do parâmetro de [addTemperatureTooHighListener]. O formato [%tT] exibe um horário na forma [HH:mm:ss]. Essa lambda não pode ter o registro cancelado: ela precisaria ter sido armazenada em uma variável para que se passasse o mesmo objeto a [removeTemperatureTooHighListener]. Por isso, lambdas escritas diretamente na chamada de registro são reservadas para listeners que permanecem registrados enquanto o emissor existir;
  • linhas 19–33: laço de entrada de temperaturas pelo teclado. [readlnOrNull()] lê uma linha; retorna [null] se a entrada padrão estiver fechada, caso que é tratado como uma entrada vazia por meio de [isNullOrBlank] (linha 23). Após esse teste, o compilador sabe que [input] não é [null] (conversão inteligente de tipo);
  • linha 27: [toDoubleOrNull] aceita somente o ponto decimal. Para permitir que um usuário francês digite [22,5], a vírgula é substituída por um ponto. Se a entrada não for um número, [toDoubleOrNull] retorna [null]: não é preciso capturar uma exceção como faz a versão Java com [Double.parseDouble];
  • Linha 33: se a temperatura digitada for válida, ela é atribuída à propriedade [temperature] do emissor [e1], cujo acessor [set] sinaliza o evento [TemperatureTooHigh] se ela for maior que 19 °C.

Os resultados mostram (os horários variam de uma execução para outra):

  • linha 1: 17 °C não ultrapassa o limite: nenhum evento;
  • linhas 2–6: 21 °C dispara o evento. Os três listeners são notificados na ordem em que foram registrados. [s1], que aceita apenas um alerta, cancela a inscrição imediatamente, mas isso não impede que o log, registrado depois dele, seja notificado;
  • linhas 9–11: [s1] não é mais notificado: o cancelamento por meio de uma nova referência funcionou como esperado;
  • linhas 12–15: [s0] recebe seu terceiro alerta e, por sua vez, cancela a inscrição;
  • linhas 16–17: resta apenas o log.

O que aconteceria se houvesse simplesmente uma [ArrayList] no lugar da [CopyOnWriteArrayList] na classe [Emitter]? Nós testamos: quando [s1] cancela a inscrição enquanto a lista está sendo processada, os itens seguintes são ignorados e o processamento é interrompido imediatamente. O log não é notificado das temperaturas 21 e 25, sem nenhuma mensagem de erro. Em outras configurações, o laço lança uma [ConcurrentModificationException]. Uma lista de listeners deve, portanto, sempre admitir modificações enquanto é percorrida: a [CopyOnWriteArrayList] foi projetada para isso e também admite inscrições e cancelamentos feitos por outras threads (Capítulo 8).

7.6.3. Eventos de mudança de propriedade

O tipo de evento mais comum ocorre quando uma propriedade de um objeto muda de valor: outro objeto (uma interface gráfica, um cache, um log) quer ser notificado dessa mudança. Kotlin e a biblioteca Java oferecem duas ferramentas complementares para esse cenário:

  • As propriedades delegadas de Kotlin. Uma propriedade declarada como [var p: T by delegate] delega a leitura e a escrita de seu valor a outro objeto, o delegado. A biblioteca padrão fornece vários deles, como [by lazy { … }], que calcula o valor da propriedade no primeiro acesso. O objeto [kotlin.properties.Delegates] fornece dois delegados que aceitam uma lambda: [Delegates.observable(initialValue) { property, old, new -> … }] executa a lambda depois de cada escrita na propriedade; [Delegates.vetoable(initialValue) { property, old, new -> … }] executa-a antes e aceita o novo valor somente se a lambda retornar [true]. O parâmetro [property] é uma referência à propriedade ([KProperty]), cujo nome é obtido por meio de [property.name];
  • a classe Java [java.beans.PropertyChangeSupport], que gerencia para nós a lista de listeners. Os listeners implementam a interface funcional [PropertyChangeListener], cujo método [void propertyChange(PropertyChangeEvent evt)] recebe um evento contendo a origem, o nome da propriedade e seus valores antigo e novo.

O delegado [observable] sabe quando uma propriedade muda, e [PropertyChangeSupport] sabe quem notificar: o programa [Lambdas12.kt] os liga entre si:

package lambdas12

import java.beans.PropertyChangeListener
import java.beans.PropertyChangeSupport
import kotlin.properties.Delegates
import kotlin.properties.ReadWriteProperty

// eventos de mudança de propriedade: Delegates.observable, vetoable e PropertyChangeSupport

fun main() {
    val thermometer = Thermometer("living room")
    // um listener de todas as propriedades
    val log = PropertyChangeListener { e ->
        val source = e.source as Thermometer
        println("Log: ${source.name}.${e.propertyName} : ${e.oldValue} -> ${e.newValue}")
    }
    thermometer.addPropertyChangeListener(log)
    // um listener apenas da propriedade temperature
    thermometer.addPropertyChangeListener("temperature") { e ->
        if (e.newValue as Double > 19) {
            println("Alert: temperature too high")
        }
    }

    thermometer.temperature = 18.0
    thermometer.temperature = 21.5
    // mesmo valor: nenhum evento
    thermometer.temperature = 21.5
    thermometer.name = "lounge"
    // cancelamento do registro do log
    thermometer.removePropertyChangeListener(log)
    thermometer.temperature = 22.0
    println("remaining listeners: ${thermometer.nbListeners}")

    // uma propriedade que pode recusar um novo valor
    for (value in listOf(21.0, 45.0)) {
        thermometer.setpoint = value
        println("requested setpoint: $value, retained setpoint: ${thermometer.setpoint}")
    }
}

// uma classe cujas propriedades sinalizam suas mudanças
class Thermometer(name: String) {
    // o gerenciamento dos listeners é delegado a um objeto PropertyChangeSupport
    private val changes = PropertyChangeSupport(this)

    // uma propriedade observável: após cada escrita, a mudança é sinalizada
    private fun <T> observable(initialValue: T): ReadWriteProperty<Any?, T> =
        Delegates.observable(initialValue) { property, old, new ->
            changes.firePropertyChange(property.name, old, new)
        }

    var name: String by observable(name)
    var temperature: Double by observable(0.0)

    // uma propriedade que recusa valores fora do intervalo [5, 30]
    var setpoint: Double by Delegates.vetoable(20.0) { _, _, new -> new in 5.0..30.0 }

    // registro e cancelamento do registro dos listeners
    fun addPropertyChangeListener(listener: PropertyChangeListener) {
        changes.addPropertyChangeListener(listener)
    }

    fun addPropertyChangeListener(property: String, listener: PropertyChangeListener) {
        changes.addPropertyChangeListener(property, listener)
    }

    fun removePropertyChangeListener(listener: PropertyChangeListener) {
        changes.removePropertyChangeListener(listener)
    }

    val nbListeners: Int
        get() = changes.propertyChangeListeners.size
}

Resultados:

1
2
3
4
5
6
7
8
9
> gradlew -q run -Pmain=lambdas12.Lambdas12Kt
Log: living room.temperature : 0.0 -> 18.0
Log: living room.temperature : 18.0 -> 21.5
Alert: temperature too high
Log: lounge.name : living room -> lounge
Alert: temperature too high
remaining listeners: 1
requested setpoint: 21.0, retained setpoint: 21.0
requested setpoint: 45.0, retained setpoint: 21.0

Comentários:

  • Linhas 3–4: o pacote [java.beans] pertence ao módulo [java.desktop] do JDK, e não ao módulo [java.base]. Como nosso programa não é um módulo Java, todas as classes do JDK estão acessíveis a ele: basta importá-las;
  • Linha 45: a classe [Thermometer] delega o gerenciamento de seus listeners a um objeto [PropertyChangeSupport], construído com a origem do evento ([this]). Os métodos das linhas 60–69 apenas repassam a ele as inscrições e os cancelamentos, e a propriedade [nbListeners] (linhas 72–73) retorna o número de listeners registrados;
  • linhas 48–50: uma pequena função genérica que cria um delegado [Delegates.observable] cuja lambda repassa cada mudança a [firePropertyChange], junto com o nome da propriedade ([property.name]), o valor antigo e o valor novo. Ela retorna uma *[ReadWriteProperty<Any?, T>]*, a interface dos delegados de propriedades mutáveis. Como um método, uma lambda escrita dentro de uma classe pode acessar as propriedades privadas do objeto, neste caso [changes];
  • linhas 53–54: as duas propriedades observáveis da classe. A palavra-chave [by] delega o gerenciamento delas a um delegado criado por nossa função [observable]. Em comparação com a versão Java, em que cada setter precisa guardar o valor antigo, armazenar o novo e chamar *[firePropertyChange] com o nome da propriedade escrito como string, a versão Kotlin cabe em uma única linha por propriedade, e o nome da propriedade não pode ser escrito errado. O delegado executa a lambda a cada escrita, mesmo que o valor não mude; no entanto, [firePropertyChange]* só notifica os listeners se os dois valores forem diferentes: a escrita da linha 28, que não altera o valor, não produz, portanto, nenhuma saída;
  • linhas 13–17: um primeiro observador, uma lambda convertida em [PropertyChangeListener] e armazenada em uma variável para que possa cancelar a inscrição (linha 31). Ela está inscrita em todas as propriedades do objeto. [e.source] (isto é, [e.getSource()], visto de Kotlin como uma propriedade) é do tipo [Any], que precisa ser convertido com [as]. Os valores são objetos: os objetos [Double] são exibidos por meio de seu método [toString], que usa o ponto decimal;
  • Linhas 19–21: um segundo listener, registrado somente para a propriedade [temperature]. A lambda é movida para fora dos parênteses e convertida em [PropertyChangeListener] (conversão SAM). Ela dispara um alerta quando a temperatura ultrapassa 19 °C. [e.newValue as Double] converte o novo valor, do tipo [Any?], em Double;
  • Linhas 25–33: as mudanças de propriedade são feitas por meio de simples atribuições. A mudança de nome (linha 29) é informada apenas ao log. Na linha 4 dos resultados, o log exibe o novo nome da origem, [lounge]: o evento é informado depois da mudança. Depois de cancelar a inscrição no log, apenas o alerta é exibido, e resta um único listener;
  • linha 57: a propriedade [setpoint] usa o delegado [vetoable]. Sua lambda, chamada antes de cada operação de escrita, aceita o novo valor somente se ele estiver entre 5 e 30 °C ([new in 5.0..30.0]); seus dois primeiros parâmetros, desnecessários aqui, são denotados por [_]. Linhas 36–38: o valor 21 é aceito, enquanto o valor 45 é rejeitado; a propriedade mantém o valor anterior (linhas 7–8 dos resultados). As instâncias de JavaBeans têm um mecanismo equivalente, com [VetoableChangeSupport] e listeners que lançam uma [PropertyVetoException].

Sem escrever uma classe de evento nem um tipo de listener, obtemos assim um mecanismo completo. [PropertyChangeSupport] é o usado pelos componentes de interface gráfica Swing e pelos JavaBeans; JavaFX tem seu próprio mecanismo, muito parecido, para propriedades observáveis. Os delegados [observable] e [vetoable], por outro lado, bastam por si sós quando há um único observador, conhecido no momento em que a classe é escrita. Por fim, observe que, para fluxos de eventos assíncronos, Kotlin oferece o [Flow] da biblioteca kotlinx.coroutines, que veremos no Capítulo 9 ([StateFlow], em particular, funciona como uma propriedade observável).

7.7. Lambdas, coleções e sequências

No Capítulo 5, usamos as operações funcionais das coleções ([filter], [map], [sortedBy]…) e das sequências, passando-lhes lambdas. Agora sabemos o que são esses parâmetros: a função [filter] é declarada da seguinte forma na biblioteca padrão: [inline fun <T> Iterable<T>.filter(predicate: (T) -> Boolean): List<T>].

É uma função de extensão, [inline], cujo parâmetro é um tipo funcional: qualquer função ou lambda que receba um elemento e retorne um Boolean serve. Da mesma forma, [map] espera um [(T) -> R], [sortedBy] espera um [(T) -> R?], com [R] comparável, [forEach] corresponde a um [(T) -> Unit], [reduce] a um [(S, T) -> S]… Para entender plenamente como funcionam, vamos escrever nossas próprias operações de filtragem e transformação. Aqui está o programa [Lambdas13.kt]:

package lambdas13

// lambdas, coleções e sequências

fun main() {
    val numbers = listOf(3, 8, 1, 6, 5, 4, 9, 2)

    // 1 - filter e map esperam funções (T) -> Boolean e (T) -> R
    val isEven: (Int) -> Boolean = { it % 2 == 0 }
    val square: (Int) -> Int = { it * it }
    println("collections: ${numbers.filter(isEven).map(square)}")
    // a API Stream do Java continua utilizável: as lambdas são convertidas em Predicate e Function
    println("Stream: ${numbers.stream().filter { it % 2 == 0 }.map { it * it }.toList()}")

    // 2 - nossa própria função de filtragem, chamada com uma lambda e depois com uma referência
    println("filterBy(n > 4): ${numbers.filterBy { it > 4 }}")
    println("filterBy(isOdd): ${numbers.filterBy(::isOdd)}")

    // 3 - uma coleção é avaliada imediatamente: cada etapa produz uma lista completa
    val largeList = numbers.filter {
        print("[test $it] ")
        it > 7
    }
    println()
    println("the list is already computed: $largeList")

    // 4 - uma sequência é avaliada sob demanda:
    //     o predicado só é chamado pela operação terminal
    val large = numbers.asSequence().filter {
        print("[test $it] ")
        it > 7
    }
    println("the sequence is defined, nothing has been executed yet")
    large.forEach { print("-> $it ") }
    println()

    // 5 - nossas próprias operações intermediárias sobre sequências, também preguiçosas
    val cities = listOf("Angers", "Paris", "Lyon", "Nantes", "Aix")
    val result = cities.asSequence()
        .keep { it.length <= 5 }
        .transform(String::uppercase)
        .toList()
    println("our operations: $result")
    // uma sequência infinita: apenas os elementos solicitados são calculados
    val powersOfTwo = generateSequence(1) { it * 2 }
    val firstOnes = powersOfTwo.transform { "2^${it.countTrailingZeroBits()}=$it" }.take(5)
    println("powers of 2: ${firstOnes.toList()}")
}

// filtra uma lista com um predicado: o trabalho que filter faz
inline fun <T> List<T>.filterBy(predicate: (T) -> Boolean): List<T> {
    val result = mutableListOf<T>()
    for (element in this) {
        if (predicate(element)) {
            result.add(element)
        }
    }
    return result
}

fun isOdd(n: Int) = n % 2 != 0

// uma operação intermediária de sequência que deixa passar apenas os elementos que satisfazem o predicado
fun <T> Sequence<T>.keep(predicate: (T) -> Boolean): Sequence<T> = sequence {
    for (element in this@keep) {
        if (predicate(element)) yield(element)
    }
}

// uma operação intermediária que transforma cada elemento: o equivalente a map
fun <T, R> Sequence<T>.transform(transformation: (T) -> R): Sequence<R> = sequence {
    for (element in this@transform) {
        yield(transformation(element))
    }
}

Resultados:

> gradlew -q run -Pmain=lambdas13.Lambdas13Kt
collections: [64, 36, 16, 4]
Stream: [64, 36, 16, 4]
filterBy(n > 4): [8, 6, 5, 9]
filterBy(isOdd): [3, 1, 5, 9]
[test 3] [test 8] [test 1] [test 6] [test 5] [test 4] [test 9] [test 2]
the list is already computed: [8, 9]
the sequence is defined, nothing has been executed yet
[test 3] [test 8] -> 8 [test 1] [test 6] [test 5] [test 4] [test 9] -> 9 [test 2]
our operations: [PARIS, LYON, AIX]
powers of 2: [2^0=1, 2^1=2, 2^2=4, 2^3=8, 2^4=16]

Comentários:

  • Linhas 9–11: as lambdas de [filter] e de [map] são primeiro atribuídas a variáveis para revelar seus tipos. [map] transforma cada elemento: o resultado são os quadrados dos números pares;
  • linha 13: o mesmo cálculo usando o stream da API Java, que pode ser usado como está a partir de Kotlin: o método Java [filter] espera um [Predicate], [map] espera um [Function], e as lambdas de Kotlin são convertidas automaticamente (conversão SAM). Raramente é usado em Kotlin para cálculos sequenciais, já que as funções de coleções e sequências são mais simples; continua útil para os streams paralelos do Capítulo 8, ou quando uma biblioteca Java retorna um [Stream];
  • Linhas 51–58: nossa função [filterBy], escrita como função de extensão de [List<T>] e declarada como [inline], exatamente como [filter]. Ela é genérica: filtra uma lista de elementos de qualquer tipo [T]. Percorre a lista ([this]), chama o predicado para cada elemento (linha 54) e retorna a lista dos elementos selecionados;
  • Linha 16: chamada a [filterBy] com uma lambda, fora dos parênteses. O tipo [T] é inferido a partir da lista: [Int]. Na linha 17, é passada a ela uma referência de função: [isOdd] (linha 61) tem a forma [(Int) -> Boolean];
  • Linhas 20–25: um predicado verboso, que exibe cada elemento que testa, aplicado a uma lista. As operações de coleção são imediatas: [filter] testa todos os elementos e constrói a lista de resultado completa antes de retornar (linhas 5–6 dos resultados). Em uma cadeia [list.filter { … }.map { … }], cada etapa cria, portanto, uma lista intermediária;
  • linhas 29–34: o mesmo predicado aplicado a uma sequência ([asSequence()]). O resultado (linhas 7–8) mostra que a definição da sequência não executa nada: a mensagem da linha 33 é exibida antes do primeiro teste. Somente quando a operação terminal [forEach] solicita os elementos é que o predicado é executado, e os testes se alternam com as exibições de [forEach]: cada elemento percorre toda a cadeia antes que o seguinte entre nela. Essa é a execução adiada (ou preguiçosa) das sequências, a mesma dos streams Java. As operações intermediárias das sequências não são [inline]: elas precisam reter as lambdas para executá-las mais tarde;
  • linhas 64–73: para escrever nossas próprias operações intermediárias — que são preguiçosas, como as da biblioteca —, usamos o construtor de sequências [sequence]. Ele recebe uma lambda na qual a função [yield] produz um elemento da sequência: para cada elemento solicitado pelo consumidor a jusante, a lambda retoma a execução de onde parou, até o próximo [yield] (trata-se de uma corrotina, conceito que estudaremos no Capítulo 9). O rótulo [this@keep] designa o receptor da função de extensão [keep], isto é, a sequência original: sem rótulo, [this] designaria o receptor da lambda de [sequence], já que essa lambda é uma lambda com receptor. A função [keep] deixa passar apenas os elementos que satisfazem o predicado; a função [transform], que é duplamente genérica ([T] é o tipo dos elementos recebidos, [R] é o tipo dos elementos produzidos), retorna o resultado da função aplicada a cada elemento. Java 24 introduziu coletores intermediários ([Gatherer]) com a mesma finalidade, com uma sintaxe bem mais complexa;
  • linhas 39–42: nossas funções de extensão se encaixam na cadeia exatamente como as operações da biblioteca: mantemos as cidades com no máximo 5 letras e depois as convertemos para maiúsculas. A operação terminal [toList] dispara o cálculo;
  • linhas 45–47: [generateSequence(1) { it * 2 }] define uma sequência infinita: 1, seguido de cada elemento obtido dobrando o anterior. Ela só é utilizável graças à avaliação preguiçosa: [take(5)] solicita apenas os cinco primeiros elementos, e somente esses são calculados. A lambda passada a [transform] exibe cada potência na forma [2^n=value] ([countTrailingZeroBits] conta os zeros mais à direita na representação binária, ou seja, o expoente).

Todas as operações sobre coleções e sequências são construídas sobre esse modelo: funções de ordem superior que recebem tipos funcionais. Para coleções, essas funções são [inline] e imediatas; para sequências, elas preservam as lambdas e só calculam os elementos quando a operação terminal os solicita.

7.8. Árvores de expressão

Algumas linguagens, como C#, permitem converter uma lambda não em código executável, mas em uma estrutura de dados que a descreve (uma "árvore de expressão"): um programa pode então analisar a lambda [t => t.Limit > 20000] e traduzi-la, por exemplo, em uma cláusula SQL [WHERE limits > 20000] executada pelo servidor de banco de dados.

Kotlin, como Java, não tem um equivalente: uma lambda de Kotlin é sempre compilada em código executável; ela pode ser chamada, mas seu funcionamento interno não pode ser examinado. Várias ferramentas chegam perto, no entanto:

  • As referências a propriedades: [Person::age] é um objeto ([KProperty1<Person, Int>]) que conhece o nome da propriedade ([Person::age.name]) e seu tipo. Uma biblioteca pode usar isso para construir uma consulta sem escrever uma string: é o que faz o Spring Data MongoDB, por exemplo, com suas extensões Kotlin, que permitem escrever um critério como [Person::age gt 18];
  • As DSLs internas ("Domain-Specific Languages", linguagens específicas de domínio): graças às lambdas com receptor, às funções [infix] e à sobrecarga de operadores, uma biblioteca Kotlin pode oferecer uma sintaxe semelhante a SQL, que o programa executa para construir uma estrutura de dados que descreve a consulta. Esse é o princípio da biblioteca Exposed, da JetBrains: [Brackets.selectAll().where { Brackets.limit greater 20000 }];
  • plugins do compilador: o compilador Kotlin pode ser estendido com plugins que transformam o código. É assim que funciona o kotlinx.serialization, os plugins [all-open] e [no-arg] usados com Spring e Hibernate, ou o plugin [power-assert], que analisa a expressão de uma asserção para exibir seus detalhes em caso de falha. No entanto, são ferramentas de desenvolvimento, e não recursos embutidos do programa.

Hibernate, que veremos no Capítulo 11, oferece as mesmas soluções que em Java: uma linguagem de consulta semelhante a SQL, mas expressa em termos de classes e propriedades, HQL (["from Bracket t where t.limit > 20000"]), e a API Criteria do Jakarta Persistence, que constrói a consulta por meio de chamadas de método ([cb.gt(t.get("limit"), 20000)]). Nos dois casos, a consulta é um dado (uma string ou uma árvore de objetos) que Hibernate traduz em SQL, ao passo que uma lambda passada a [filter] é executada dentro do programa Kotlin.

7.9. Conclusão

Principais pontos deste capítulo:

  • Em Kotlin, funções são valores: elas têm um tipo funcional ([(Int, Int) -> Int], [() -> Unit], [(T) -> Boolean], [(() -> Unit)?], [T.() -> R]…), podem ser armazenadas em variáveis, passadas como parâmetros, retornadas como resultados e chamadas como funções comuns. Para a máquina virtual, são objetos que implementam as interfaces [Function0], [Function1]…;
  • as interfaces de [java.util.function] ([Function], [Supplier], [Consumer], [Predicate]…), junto com [Runnable], [Callable] e [Comparator], continuam utilizáveis: quando um método Java espera uma interface funcional, Kotlin converte automaticamente uma lambda ou uma referência nela (conversão SAM); nos demais casos, a conversão é escrita explicitamente: [Comparator { … }];
  • para dar nome a um tipo de função, temos o alias [typealias] (simplesmente um alias) e [fun interface] (um verdadeiro tipo novo, implementável por meio de uma lambda);
  • uma função pode ser obtida por meio de uma expressão lambda ([{ a, b -> a + b }], [{ it * it }] — escrita fora dos parênteses quando é o último parâmetro e encerrada com [return@label]), de uma função anônima, de um objeto anônimo ou de uma referência ([::function], [object::method], [Class::method], [::Class]). Duas referências à mesma função do mesmo objeto são iguais; duas lambdas nunca são iguais;
  • as lambdas capturam as variáveis ao seu redor, inclusive as [var], que elas podem modificar (o compilador as armazena em objetos [Ref]); elas então enxergam o valor da variável no momento de sua execução, o que exige cautela em laços e entre threads;
  • funções que retornam funções e extensões sobre tipos funcionais ([then], [and], [or]…) compõem novas funções; [compareBy], [thenBy] e [reversed] constroem comparadores;
  • as funções [inline] copiam seu código e o das lambdas para o local da chamada, sem objeto nem conversão, e permitem retornos não locais; [noinline] e [crossinline] tratam casos especiais. As funções de escopo [let], [run], [with], [apply] e [also] são as aplicações mais comuns disso;
  • escolhe-se um tipo funcional para comportamentos curtos e pontuais; uma [fun interface] para um tipo distinto ou uma API que possa ser usada a partir de Java; uma interface com vários membros (ou uma interface "de negócio") para um papel da aplicação;
  • um evento é implementado pelo padrão listener: uma classe [XxxEvent], um tipo de listener (muitas vezes um [typealias] de tipo funcional), [addXxxListener] / [removeXxxListener], e uma lista de funções ([CopyOnWriteArrayList]) percorrida por um método [fireXxx]. As propriedades delegadas [Delegates.observable] e [Delegates.vetoable] sinalizam ou filtram as mudanças de uma propriedade, e [PropertyChangeSupport] gerencia para elas a lista de listeners;
  • as operações de coleção (imediatas, [inline]) e as operações de sequência (preguiçosas) são funções de ordem superior; Kotlin não tem árvores de expressão, e Hibernate expressa suas consultas por meio de HQL ou da API Criteria.

As lambdas reaparecerão em todos os capítulos seguintes: uma thread executa uma lambda ([thread { … }]), e um [ExecutorService] executa um [Callable] (Capítulo 8); uma corrotina é iniciada por [launch { … }] ou [async { … }] (Capítulo 9), funções de extensão de [ResultSet] receberão, na forma de uma lambda, a transformação de uma linha do resultado em um objeto (Capítulo 10), e os serviços web do Spring Boot processam requisições HTTP em métodos que o framework chama como listeners (Capítulo 13).