Scala for Backend Engineering & Functional Programming · Lección

Composición

andThen y compose

Composición es una lección gratuita de Scala for Backend Engineering & Functional Programming en CoddyKit. Esta es la lección 3 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Scala for Backend Engineering & Functional Programming, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Scala for Backend Engineering & Functional Programming incluye 4 lecciones en total.

Combinar funciones

La composición de funciones consiste en crear una función nueva conectando dos existentes, de modo que la salida de una se convierte en la entrada de la siguiente. Scala proporciona andThen y compose para ello.

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: de izquierda a derecha

f andThen g ejecuta primero f y después g. Leerlo de izquierda a derecha coincide con el orden de ejecución, lo que muchas personas consideran 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: de derecha a izquierda

f compose g ejecuta primero g y después f, siguiendo el orden matemático 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 frente a compose

Ambas son imágenes especulares:

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

Elija la opción que se lea de forma más natural en su situación.

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))
  }
}

Encadenar varias funciones

Puede encadenar muchas funciones usando varios andThen para crear una canalización más larga que avance de arriba abajo.

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  "))
  }
}

La composición cambia los tipos

Las funciones compuestas necesitan tipos compatibles: el tipo de salida de la primera debe coincidir con el tipo de entrada de la segunda. La canalización puede cambiar de tipo a lo largo del proceso.

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"))
  }
}

La función identidad

identity devuelve su entrada sin modificar. Es el elemento neutro de la composición: f andThen identity == f. Resulta útil como valor predeterminado en pliegues y condicionales.

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

Componer con reduce

Como las funciones son valores, puede almacenarlas en una lista y componerlas todas mediante reduce con 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
  }
}

Crear canalizaciones reutilizables

La composición fomenta el uso de funciones pequeñas y de propósito único que se ensamblan para formar comportamientos más grandes, una idea clave de la programación 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 "))
  }
}

Composición con map

Una función compuesta sigue siendo una función, por lo que puede pasarla directamente a map para aplicar toda la canalización a una colección.

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))
  }
}

Leer atentamente el orden de composición

Un error frecuente es confundir andThen y compose. Recuerde siempre: andThen = primero esto y después aquello; compose = al revés.

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
  }
}

Comprobación rápida

Dados f y g, ¿qué calcula (f andThen g)(x)?

Repaso

Ha aprendido la composición de funciones:

f andThen g → g(f(x)) (de izquierda a derecha)
f compose g → f(g(x)) (de derecha a izquierda)
Son imágenes especulares la una de la otra
identity es el elemento neutro
Componga listas de funciones con reduce(_ andThen _)

Preguntas frecuentes

¿La lección «Composición» es gratis?

Sí — el texto completo de «Composición» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Scala for Backend Engineering & Functional Programming, actualiza a CoddyKit PRO. El curso de Scala for Backend Engineering & Functional Programming incluye 4 lecciones en total.

¿Qué aprenderé en «Composición»?

andThen y compose Practicas Scala for Backend Engineering & Functional Programming con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Scala for Backend Engineering & Functional Programming?

No se requiere experiencia previa. Scala for Backend Engineering & Functional Programming en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 3 de 4.

¿Cuánto tiempo toma la lección «Composición»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Scala for Backend Engineering & Functional Programming?

Sí. Cada lección de Scala for Backend Engineering & Functional Programming incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

← Volver a Scala for Backend Engineering & Functional Programming