Scala for Backend Engineering & Functional Programming · Aula

Composição

andThen e compose.

Composição é uma aula grátis de Scala for Backend Engineering & Functional Programming no CoddyKit. Esta é a aula 3 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.

Combinando funções

A composição de funções consiste em criar uma nova função conectando duas funções existentes, de modo que a saída de uma se torne a entrada da próxima. O Scala fornece andThen e compose para isso.

object Main {
  def main(args: Array[String]): Unit = {
    val addOne = (x: Int) => x + 1
    val double = (x: Int) => x * 2
    val both = addOne andThen double
    println(both(5))
  }
}

andThen: da esquerda para a direita

f andThen g executa f primeiro e depois g. Ler da esquerda para a direita corresponde à ordem de execução, o que muitas pessoas consideram intuitivo.

(f andThen g)(x) == g(f(x))

object Main {
  def main(args: Array[String]): Unit = {
    val addOne = (x: Int) => x + 1
    val triple = (x: Int) => x * 3
    val pipeline = addOne andThen triple
    println(pipeline(4))  // (4 + 1) * 3
  }
}

compose: da direita para a esquerda

f compose g executa g primeiro e depois f, seguindo a ordem matemática f(g(x)).

(f compose g)(x) == f(g(x))

object Main {
  def main(args: Array[String]): Unit = {
    val addOne = (x: Int) => x + 1
    val triple = (x: Int) => x * 3
    val pipeline = addOne compose triple
    println(pipeline(4))  // (4 * 3) + 1
  }
}

andThen e compose

As duas são imagens espelhadas:

f andThen g = g compose f
f compose g = g andThen f

Escolha a forma que for mais natural de ler na sua situação.

object Main {
  def main(args: Array[String]): Unit = {
    val f = (x: Int) => x + 10
    val g = (x: Int) => x * 2
    println((f andThen g)(3))
    println((g compose f)(3))
  }
}

Encadeando várias funções

Você pode encadear várias funções usando vários andThen para criar um fluxo mais longo que segue de cima para baixo.

object Main {
  def main(args: Array[String]): Unit = {
    val clean = (s: String) => s.trim
    val lower = (s: String) => s.toLowerCase
    val bang  = (s: String) => s + "!"
    val process = clean andThen lower andThen bang
    println(process("  HELLO  "))
  }
}

A composição altera os tipos

As funções compostas precisam ter tipos compatíveis: o tipo de saída da primeira deve corresponder ao tipo de entrada da segunda. O fluxo pode alterar os tipos ao longo do caminho.

object Main {
  def main(args: Array[String]): Unit = {
    val length = (s: String) => s.length
    val isLong = (n: Int) => n > 5
    val check = length andThen isLong
    println(check("scala"))
    println(check("functional"))
  }
}

A função identidade

identity retorna sua entrada sem alterações. Ela é o elemento neutro da composição: f andThen identity == f. É útil como valor padrão em dobras e condicionais.

object Main {
  def main(args: Array[String]): Unit = {
    val f = (x: Int) => x * 2
    val same = f andThen identity[Int]
    println(same(7))
  }
}

Compondo com reduce

Como as funções são valores, você pode armazenar várias em uma lista e compô-las usando reduce com andThen.

object Main {
  def main(args: Array[String]): Unit = {
    val steps: List[Int => Int] = List(_ + 1, _ * 2, _ - 3)
    val pipeline = steps.reduce(_ andThen _)
    println(pipeline(5))  // ((5+1)*2)-3
  }
}

Construindo fluxos reutilizáveis

A composição incentiva funções pequenas e de finalidade única, que você combina para formar comportamentos maiores — uma ideia fundamental da programação funcional.

object Main {
  def main(args: Array[String]): Unit = {
    val sanitize = (s: String) => s.trim.toLowerCase
    val capitalize = (s: String) => s.capitalize
    val format = sanitize andThen capitalize
    println(format("  aLiCe "))
  }
}

Composição com map

Uma função composta é simplesmente uma função, portanto você pode passá-la diretamente para map e aplicar todo o fluxo a uma coleção.

object Main {
  def main(args: Array[String]): Unit = {
    val transform = ((x: Int) => x + 1) andThen ((x: Int) => x * x)
    println(List(1, 2, 3).map(transform))
  }
}

Lendo atentamente a ordem da composição

Um erro comum é confundir andThen e compose. Lembre-se sempre: andThen = primeiro isto, depois aquilo; compose = o inverso.

object Main {
  def main(args: Array[String]): Unit = {
    val inc = (x: Int) => x + 1
    val sqr = (x: Int) => x * x
    println((inc andThen sqr)(2))  // (2+1)^2 = 9
    println((inc compose sqr)(2))  // (2^2)+1 = 5
  }
}

Verificação rápida

Dados f e g, o que (f andThen g)(x) calcula?

Recapitulação

Você aprendeu sobre composição de funções:

f andThen g → g(f(x)) (da esquerda para a direita)
f compose g → f(g(x)) (da direita para a esquerda)
Elas são imagens espelhadas uma da outra
identity é o elemento neutro
Componha listas de funções com reduce(_ andThen _)

Perguntas Frequentes

A aula “Composição” é grátis?

Sim — o texto completo de “Composição” é 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 “Composição”?

andThen e compose. 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 3 de 4.

Quanto tempo leva a aula “Composição”?

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