Funções como valores
Funções de primeira classe.
Funções como valores é uma aula grátis de Scala for Backend Engineering & Functional Programming no CoddyKit. Esta é a aula 1 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Scala for Backend Engineering & Functional Programming, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Scala for Backend Engineering & Functional Programming inclui 4 aulas no total.
Funções são valores
No Scala, as funções são valores de primeira classe. Você pode armazená-las em variáveis, passá-las como argumentos e retorná-las de outras funções, assim como números ou cadeias de caracteres.
object Main {
def main(args: Array[String]): Unit = {
val increment: Int => Int = x => x + 1
println(increment(5))
}
}Sintaxe do tipo de função
O tipo Int => String significa uma função que recebe um Int e retorna uma String. Para vários parâmetros, use parênteses: (Int, Int) => Int.
object Main {
def main(args: Array[String]): Unit = {
val add: (Int, Int) => Int = (a, b) => a + b
val label: Int => String = n => s"value=$n"
println(add(3, 4))
println(label(7))
}
}Sintaxe de lambda (função anônima)
Uma função anônima, ou lambda, é escrita como (params) => body. Ela não tem nome e costuma ser passada diretamente para outra função.
object Main {
def main(args: Array[String]): Unit = {
val square = (x: Int) => x * x
println(square(6))
}
}Funções de ordem superior
Uma função de ordem superior é aquela que recebe uma função como parâmetro ou retorna uma função. map e filter são exemplos clássicos.
object Main {
def applyTwice(f: Int => Int, x: Int): Int = f(f(x))
def main(args: Array[String]): Unit = {
println(applyTwice(_ + 3, 10))
}
}Passando funções para métodos
Os métodos de coleções aceitam funções. Você pode passar uma lambda diretamente ou passar um valor de função nomeado.
object Main {
def main(args: Array[String]): Unit = {
val triple = (x: Int) => x * 3
println(List(1, 2, 3).map(triple))
println(List(1, 2, 3).map(x => x * 3))
}
}Retornando funções
Uma função pode retornar outra função. Aqui, multiplier retorna uma função que multiplica por um fator fixo, funcionando como uma pequena fábrica de funções.
object Main {
def multiplier(factor: Int): Int => Int = x => x * factor
def main(args: Array[String]): Unit = {
val timesTen = multiplier(10)
println(timesTen(5))
}
}Métodos e funções
Um def define um método. Você pode transformar um método em um valor de função com o sublinhado da expansão eta: methodName _, ou simplesmente usá-lo onde uma função é esperada.
object Main {
def doubleIt(x: Int): Int = x * 2
def main(args: Array[String]): Unit = {
val f: Int => Int = doubleIt
println(f(8))
println(List(1, 2, 3).map(doubleIt))
}
}Funções sem parâmetros
Uma função pode não receber argumentos. Seu tipo é escrito como () => T. Isso é útil para adiar uma computação.
object Main {
def main(args: Array[String]): Unit = {
val greeting: () => String = () => "Hello!"
println(greeting())
}
}Armazenando funções em coleções
Como as funções são valores, você pode armazená-las em listas ou mapas e pesquisá-las dinamicamente, criando um pequeno distribuidor de comandos.
object Main {
def main(args: Array[String]): Unit = {
val ops: Map[String, (Int, Int) => Int] = Map(
"add" -> (_ + _),
"mul" -> (_ * _)
)
println(ops("add")(3, 4))
println(ops("mul")(3, 4))
}
}Funções como configuração
Passar uma função permite que quem chama personalize o comportamento. Aqui, uma função genérica transformAll aplica qualquer função a todos os elementos de uma lista.
object Main {
def transformAll(xs: List[Int], f: Int => Int): List[Int] = xs.map(f)
def main(args: Array[String]): Unit = {
println(transformAll(List(1, 2, 3), _ + 100))
println(transformAll(List(1, 2, 3), _ * 10))
}
}Um exemplo mais simples de personalização
Veja a mesma ideia escrita de forma mais clara: quem chama fornece a transformação, mantendo o auxiliar genérico e reutilizável.
object Main {
def transformAll(xs: List[Int], f: Int => Int): List[Int] = xs.map(f)
def main(args: Array[String]): Unit = {
println(transformAll(List(1, 2, 3), x => x + 100))
println(transformAll(List(1, 2, 3), x => x * x))
}
}Verificação rápida
O que é uma função de ordem superior?
Recapitulação
Você aprendeu que as funções são valores de primeira classe:
- Armazene funções em
vals, listas e mapas - Tipos de função como
Int => String - Lambdas:
(x) => bodye a forma abreviada com_ - Funções de ordem superior recebem ou retornam funções
- Métodos tornam-se valores de função por meio da expansão eta
Perguntas Frequentes
A aula “Funções como valores” é grátis?
Sim — o texto completo de “Funções como valores” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Scala for Backend Engineering & Functional Programming, atualize para CoddyKit PRO. O curso de Scala for Backend Engineering & Functional Programming inclui 4 aulas no total.
O que vou aprender em “Funções como valores”?
Funções de primeira classe. Você pratica Scala for Backend Engineering & Functional Programming com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.
Preciso ter experiência prévia para começar Scala for Backend Engineering & Functional Programming?
Nenhuma experiência prévia é necessária. Scala for Backend Engineering & Functional Programming no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 1 de 4.
Quanto tempo leva a aula “Funções como valores”?
A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.
Posso escrever e executar código nesta aula de Scala for Backend Engineering & Functional Programming?
Sim. Cada aula de Scala for Backend Engineering & Functional Programming inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.
Todas as aulas deste curso
- Funções como valores
- Currying
- Composição
- Closures