Scala for Backend Engineering & Functional Programming · Aula

Funções de ordem superior e currying

Explore conceitos funcionais avançados, como funções de ordem superior e currying, para criar código flexível e reutilizável.

Funções de ordem superior e currying é uma aula grátis de Scala for Backend Engineering & Functional Programming no CoddyKit. Esta é a aula 2 de 3. 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 3 aulas no total.

Desbloqueando as funções de ordem superior

Boas-vindas à Lição 2! Na programação funcional, as funções são poderosas. Elas não servem apenas para calcular valores; também podem ser tratadas como qualquer outro dado.

Isso significa que as funções podem ser passadas como argumentos para outras funções ou até mesmo retornadas como resultados por elas. Quando uma função faz isso, ela é chamada de função de ordem superior (HOF).

As HOFs recebem uma ou mais funções como argumentos.
As HOFs retornam uma função como resultado.
Ou fazem as duas coisas!

HOF em ação: `map`

Uma das HOFs mais comuns em Scala é map. Ela transforma cada elemento de uma coleção aplicando-lhe uma determinada função e retorna uma nova coleção.

Experimente executar este exemplo simples:

object Main {
  def main(args: Array[String]): Unit = {
    val numbers = List(1, 2, 3)
    val doubledNumbers = numbers.map(x => x * 2)
    println(s"Original: $numbers")
    println(s"Doubled: $doubledNumbers")
  }
}

HOF em ação: `filter`

Outra HOF útil é filter. Ela seleciona, de uma coleção, os elementos que satisfazem uma determinada condição (uma função que retorna um booleano), criando uma nova coleção.

Veja como usar filter para encontrar números pares:

object Main {
  def main(args: Array[String]): Unit = {
    val allNumbers = List(1, 2, 3, 4, 5, 6)
    val evenNumbers = allNumbers.filter(x => x % 2 == 0)
    println(s"All: $allNumbers")
    println(s"Even: $evenNumbers")
  }
}

Definindo sua própria HOF

Você não está limitado às HOFs integradas! É possível definir suas próprias funções que aceitam outras funções como parâmetros. A sintaxe para um tipo de função é (InputType => ReturnType).

Este exemplo define uma função applyOperation que recebe um Int e outra função op (que recebe um Int e retorna um Int).

object Main {
  // A HOF that applies an operation to a number
  def applyOperation(x: Int, op: Int => Int): Int = {
    op(x)
  }

  def main(args: Array[String]): Unit = {
    val result = applyOperation(10, _ * 3) // Pass an anonymous function
    println(s"Result of 10 * 3: $result")

    val anotherResult = applyOperation(7, _ + 5)
    println(s"Result of 7 + 5: $anotherResult")
  }
}

Funções anônimas e forma abreviada

Ao passar funções para HOFs, você geralmente usa funções anônimas (também chamadas de lambdas). Scala oferece formas concisas de escrevê-las.

x => x * 2: função anônima completa.
_ * 2: forma abreviada de uma função anônima com um único parâmetro.

As duas formas são comuns e tornam seu código mais curto e legível.

object Main {
  def main(args: Array[String]): Unit = {
    val numbers = List(10, 20, 30)

    // Using full anonymous function syntax
    val dividedByTwo = numbers.map(x => x / 2)
    println(s"Divided by two: $dividedByTwo")

    // Using shorthand `_` syntax
    val plusOne = numbers.map(_ + 1)
    println(s"Plus one: $plusOne")
  }
}

Introdução à aplicação parcial

Aplicação parcial é uma técnica que transforma uma função que recebe vários argumentos em uma sequência de funções, cada uma recebendo um único argumento.

O nome vem do lógico Haskell Curry. Em Scala, funções com várias listas de parâmetros são automaticamente transformadas dessa forma.

Em vez de f(arg1, arg2), você escreve f(arg1)(arg2).

Exemplo de aplicação parcial: listas com vários parâmetros

Vamos ver a aplicação parcial em ação. Observe como add recebe seus argumentos em duas listas de parâmetros separadas.

Isso permite aplicar a função parcialmente, criando novas funções ao fixar alguns argumentos.

object Main {
  // A curried function with two parameter lists
  def add(a: Int)(b: Int): Int = {
    a + b
  }

  def main(args: Array[String]): Unit = {
    // Call the function normally
    println(s"5 + 3 = ${add(5)(3)}")

    // Partially apply the first argument
    val addFive = add(5)_ // `_` tells Scala to treat it as a partially applied function
    println(s"5 + 10 = ${addFive(10)}")
    println(s"5 + 20 = ${addFive(20)}")
  }
}

Benefícios da aplicação parcial

Por que usar a aplicação parcial? Ela oferece várias vantagens na programação funcional:

Aplicação parcial: crie versões especializadas de uma função fixando alguns argumentos. Isso melhora a reutilização do código.
Composição de funções: funções transformadas dessa forma geralmente são mais fáceis de compor com outras funções.
Inferência de tipos: às vezes pode ajudar a inferência de tipos do Scala, especialmente ao trabalhar com tipos genéricos complexos.

Aplicação parcial para registradores personalizados

Imagine que você queira criar funções de registro diferentes para diferentes níveis (por exemplo, INFO e ERROR), mas usando a mesma lógica central. A aplicação parcial é perfeita para isso!

Você pode definir uma função geral log e depois aplicá-la parcialmente para criar registradores específicos.

object Main {
  def log(level: String)(message: String): Unit = {
    println(s"[$level] $message")
  }

  def main(args: Array[String]): Unit = {
    // Create specialized loggers using partial application
    val infoLogger = log("INFO")_
    val errorLogger = log("ERROR")_

    infoLogger("User logged in successfully.")
    errorLogger("Failed to connect to database!")
  }
}

Verificação rápida: HOFs e aplicação parcial

Considere o seguinte trecho de código Scala:

def calculate(x: Int)(y: Int, op: (Int, Int) => Int): Int = {
  op(x, y)
}

val add = (a: Int, b: Int) => a + b
val multiply = (a: Int, b: Int) => a * b

val result1 = calculate(10)(5, add)
val result2 = calculate(2)(3, multiply)

Quais são os valores de result1 e result2?

Recapitulação: HOFs e aplicação parcial

Excelente trabalho! Você explorou dois conceitos poderosos da programação funcional:

Funções de ordem superior (HOFs): funções que podem receber outras funções como argumentos ou retorná-las como resultados. Elas permitem criar código flexível e reutilizável, como map e filter.
Aplicação parcial: técnica para transformar uma função com vários argumentos em uma sequência de funções, cada uma recebendo um único argumento. Ela é excelente para aplicação parcial e criação de funções especializadas.

Esses conceitos são fundamentais para escrever código Scala expressivo e modular!

Perguntas Frequentes

A aula “Funções de ordem superior e currying” é grátis?

Sim — o texto completo de “Funções de ordem superior e currying” é 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 3 aulas no total.

O que vou aprender em “Funções de ordem superior e currying”?

Explore conceitos funcionais avançados, como funções de ordem superior e currying, para criar código flexível e reutilizável. 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 2 de 3.

Quanto tempo leva a aula “Funções de ordem superior e currying”?

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

← Voltar para Scala for Backend Engineering & Functional Programming