1. Como retornar varios valores de uma funcao?
Se voce esta apenas comecando a programar, e muito facil pensar: “Bom, se eu preciso retornar dois valores — eu simplesmente… retorno dois valores”. Infelizmente, a maioria das linguagens (e Kotlin inclusive) normalmente exige que uma funcao retorne exatamente um valor.
Para esse caso, os programadores tem um truque: retornar nao “dois valores”, mas um conteiner, dentro do qual estao dois valores. E e exatamente aqui que, em Kotlin, entram Pair e Triple.
Imagine uma caixa com um adesivo: “Dentro ha duas coisas”. Isso e Pair. E uma caixa “Dentro ha tres coisas” — isso e Triple. O Kotlin fornece essas caixas prontas (desculpe o trocadilho), para que voce nao reinvente a roda e nao cole os dados numa string do tipo "10,20".
Pair: conteiner de dois valores
Pair e um tipo padrao do Kotlin que armazena exatamente dois valores relacionados. Relacionados mesmo: ou seja, valores que fazem sentido juntos. Nao “almondégas e foguetes espaciais”, mas algo como “nome e idade”, “coordenada X e coordenada Y”, “codigo de resposta e texto da mensagem”.
E importante notar que Pair nao impõe significado aos componentes. Ele nao tem campos x e y, nao tem name e age. So existem os honestos e um pouco sem graca first e second. O significado vem do contexto e dos nomes das variaveis ao redor.
Criamos Pair com Pair(a, b) e lemos com first/second
O jeito mais direto: chamar o construtor Pair(...).
fun main() {
val point = Pair(10, 20)
println(point.first) // 10
println(point.second) // 20
}
Aqui point e um “ponto”, entao combinamos que first e x, e second e y. O Kotlin nao sabe disso. O Kotlin apenas armazena “o primeiro” e “o segundo”. A combinacao fica por sua conta.
Exemplo mais proximo da realidade: “valor + explicacao”
As vezes e util manter um numero e um texto curto lado a lado — por exemplo, “resultado do calculo + um comentario do que foi isso”.
fun main() {
val result = Pair(200, "OK")
println("code=${result.first}") // code=200
println("message=${result.second}") // message=OK
}
Repare: ler result.first diz pouca coisa sobre o que esta armazenado ali. Por isso, normalmente ou damos a variavel um nome mais especifico, ou (na proxima aula) vamos desempacotar isso via desestruturacao. Mas hoje treinamos honestamente a leitura dos valores via first/second.
3. Triple: conteiner de tres valores
Triple e o irmao gemeo do Pair, so que ele tem tres valores dentro. Isso e conveniente quando os dados sao realmente tres e formam um unico conjunto de significado. O exemplo classico e RGB: vermelho, verde, azul.
Assim como no Pair, os nomes dos componentes sao sem graca, mas obvios: first, second, third. O Kotlin parece dizer: “Eu so armazeno. O significado e trabalho de voce”.
Criamos Triple e lemos com first/second/third
fun main() {
val rgb = Triple(255, 128, 0)
println("r=${rgb.first}") // r=255
println("g=${rgb.second}") // g=128
println("b=${rgb.third}") // b=0
}
Cola: como ler os componentes
Quando os olhos cansam de first/second/third, e util ter uma cola simples.
| Tipo | Quantos valores armazena | Como ler os componentes |
|---|---|---|
|
2 | |
|
3 | |
4. Criacao conveniente: to e inferencia de tipos
Agora vai ter um pedacinho de “magia do Kotlin”, mas nao tenha medo: a magia aqui e do bem.
Além de Pair(a, b), existe uma notacao super popular:
val range = 1 to 10
Ela cria Pair(1, 10).
Essa forma funciona porque to e uma funcao que o Kotlin permite chamar na forma infix (infixa): quando o nome da funcao fica entre dois valores. O Kotlin descreve as regras das chamadas infixas (a funcao deve ter um parametro e mais alguns requisitos) numa documentacao separada sobre notacao infixa.
a to b e um par, nao um “sintaxe especial”
E importante entender: to nao e “parte da linguagem para pares”, e uma funcao comum (so que e conveniente usa-la na forma infixa). Portanto, a to b e exatamente a criacao de Pair(a, b).
Importante: 1 to 10 nao e o intervalo 1..10
Muito importante: 1 to 10 nao e o intervalo 1..10. E apenas um par de valores, em que first = 1, second = 10.
fun main() {
val fromTo = 1 to 10
println("from=${fromTo.first}") // from=1
println("to=${fromTo.second}") // to=10
}
De nomes de variaveis “falantes”
A legibilidade de Pair quase sempre depende dos nomes das variaveis. Se voce nomear a variavel bem, o codigo fica visivelmente mais amigavel.
fun main() {
val minMax = 3 to 12
println("min=${minMax.first}") // min=3
println("max=${minMax.second}") // max=12
}
A notacao a to b e tao comum que o Kotlin a usa diretamente em exemplos da documentacao quando e preciso “combinar pares”.
Quais tipos ficam dentro de Pair/Triple
Agora vem um ponto importante: Pair e Triple conseguem armazenar qualquer coisa. Quer Int e String? Sem problema. Quer String e Boolean? Tambem da. E o Kotlin, nesse processo, muitas vezes infere os tipos sozinho, como ja estamos acostumados com variaveis.
Ou seja, se voce escreve val p = 10 to 20, o Kotlin entende que isso e Pair<Int, Int>. Mas hoje nao vamos entrar em detalhes — isso vai ser bem mais tarde. Por enquanto, basta entender a pratica: os tipos dentro do par correspondem ao que voce colocou nele.
Pair de tipos diferentes
fun main() {
val user = Pair("Ada", 36)
println(user.first) // Ada
println(user.second) // 36
}
Aqui first e string, second e numero. O Kotlin lida com isso perfeitamente.
Triple — so se for um unico significado, e nao um “saco de tudo”
So lembre: Triple nao e um saco de “o que mais da para enfiar”. Se os tres valores nao formam uma unica ideia, depois voce mesmo vai olhar para isso como um enigma.
fun main() {
val movie = Triple("Matrix", 1999, true)
println(movie.first) // Matrix
println(movie.second) // 1999
println(movie.third) // true
}
Funciona? Sim. E legivel? Mais ou menos. Porque true e “o que”? “Ja assistiu”? “Gostou”? “O filme existe”? E por isso que Pair/Triple devem ser usados com cuidado.
5. Aplicacao: “rascunho de despesas” no console
Para nao deixar Pair e Triple no mundo das pontos e cores abstratas, vamos comecar a desenvolver um pequeno aplicativo de console educativo. Que seja um “rascunho de controle de despesas” super minimalista: o usuario digita a categoria e o valor, e nos imprimimos uma confirmacao clara.
Hoje nossa tarefa e simples: aprender a armazenar um registro de despesa como o conjunto “categoria + valor”. Para isso, Pair e perfeito: dois valores, um significado.
Criamos uma “despesa” como Pair
fun main() {
val expense = "food" to 250
println("Category: ${expense.first}") // Category: food
println("Amount: ${expense.second}") // Amount: 250
}
Sim, food e 250 poderiam ser armazenados em duas variaveis. Mas a ideia e: as vezes e conveniente passar isso adiante como um unico objeto: “aqui esta a despesa completa”.
Lemos os dados e montamos um Pair
Ja sabemos readln() e toIntOrNull(). Nao vamos complicar: vamos supor que o usuario digita a categoria na primeira linha e o valor na segunda.
fun main() {
print("Enter category: ")
val category = readln().trim()
print("Enter amount: ")
val amountText = readln().trim()
val amount = amountText.toInt()
val expense = category to amount
println("Saved: ${expense.first} -> ${expense.second}") // exemplo: Saved: food -> 250
}
Isso ainda nao e um controle de despesas “de verdade”, mas como passo de aprendizado — excelente: vimos como Pair vira uma pequena “embalagem” para informacao relacionada.
Quando Pair/Triple fazem sentido e quando e melhor parar
Pair e Triple sao como fita adesiva. E util no dia a dia, mas se voce construiu uma nave espacial so de fita adesiva, talvez tenha deixado passar algo no projeto.
Normalmente Pair/Triple sao adequados quando os valores sao realmente pequenos, sao poucos, e voce entende rapidamente pelo contexto o que significa first e second. Por exemplo, x to y para uma coordenada, min to max para limites, code to message para resultado.
Mas se voce se pega pensando o tempo todo “e o first — e o que mesmo?” e comeca a escrever comentarios do tipo // first = category, second = amount, isso e um sinal: talvez voce precise de um resultado mais “nomeado”. Mas como fazer isso do jeito certo eu vou contar para voce daqui a uns 10 niveis.
7. Erros tipicos ao trabalhar com Pair e Triple
Erro no 1: confusao na ordem dos componentes (first/second).
O problema mais comum e confundir o que esta em first e o que esta em second. Principalmente quando, em diferentes partes do codigo, voce cria pares parecidos, mas “combinou de um jeito diferente”: em um lugar (min, max) e em outro (max, min). Isso nao e um erro do compilador — e um erro de significado. O que salva e disciplina: fixe a ordem e mantenha-a igual em todo lugar, e de nomes as variaveis de forma que sugiram essa ordem (minMax, fromTo, xToY).
Erro no 2: usar Pair para dados nao relacionados “porque da”.
Tecnicamente, voce pode colocar qualquer coisa em Pair. Mas se os dois valores nao formam um unico significado, a leitura vira um quebra-cabeca. Depois de uma semana, voce vai abrir o codigo e vai ficar tentando adivinhar por que val x = pair.first, e o que e esse x afinal? Pair nao e um “pacote para viagem” para sobras aleatorias.
Erro no 3: achar que first significa “o principal”.
As vezes, iniciantes acham que first e o “campo principal” e second e “o adicional”. O Kotlin nao pensa assim. Nao existe principal e secundario, existe apenas a ordem. Se o significado exige “principalidade”, isso precisa ser expresso pelos nomes das variaveis e pela logica do codigo, e nao esperando magia da palavra first.
Erro no 4: Triple como um “saco de tudo”.
Triple vira facilmente um mini-caos: “coloca o nome, a idade, um flag, e… opa, nao tem quarto lugar”. Se voce ja sente que Triple nao comporta um significado real, isso nao e um “Triple ruim”; e um bom sinal de que o modelo de dados pede uma forma mais adequada. Por enquanto, apenas memorize esse sinal — vamos voltar a ele no futuro, quando tivermos nossos proprios tipos.
Erro no 5: cadeias longas de .first.first....
Quando voce comeca a ver construcoes como something.first.second, significa que em algum lugar voce colou um Pair dentro de outro Pair e ja criou um labirinto para si mesmo. Nessa situacao, e melhor parar e colocar os valores intermediarios em variaveis com nomes normais. Mesmo que fique duas linhas mais longo — vai custar menos para o cerebro do que decifrar uma “matrioshka de first’s”.
GO TO FULL VERSION