Scala for Backend Engineering & Functional Programming · Lección

Currificación

Aplicación parcial

Currificación es una lección gratuita de Scala for Backend Engineering & Functional Programming en CoddyKit. Esta es la lección 2 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.

¿Qué es la currificación?

La currificación transforma una función con varios argumentos en una cadena de funciones, cada una de las cuales recibe un argumento. En Scala se escribe mediante varias listas de parámetros.

object Main {
  def add(a: Int)(b: Int): Int = a + b
  def main(args: Array[String]): Unit = {
    println(add(3)(4))
  }
}

Varias listas de parámetros

Un método currificado tiene varias listas de parámetros: def f(a: Int)(b: Int). Se llama proporcionando cada lista por turnos: f(1)(2).

object Main {
  def combine(prefix: String)(value: Int): String = s"$prefix$value"
  def main(args: Array[String]): Unit = {
    println(combine("id-")(42))
  }
}

Aplicación parcial

Puede aplicar solo algunas listas de argumentos y obtener una función que espera el resto. Esto se denomina aplicación parcial.

object Main {
  def add(a: Int)(b: Int): Int = a + b
  def main(args: Array[String]): Unit = {
    val addFive = add(5) _
    println(addFive(10))
    println(addFive(20))
  }
}

Especializar una función general

La aplicación parcial permite crear funciones especializadas a partir de una función general, reduciendo la repetición.

object Main {
  def power(exp: Int)(base: Int): Int = math.pow(base, exp).toInt
  def main(args: Array[String]): Unit = {
    val square = power(2) _
    val cube = power(3) _
    println(square(5))
    println(cube(2))
  }
}

Currificar una función normal

Un valor de función ordinario tiene un método .curried que lo convierte a la forma currificada.

object Main {
  def main(args: Array[String]): Unit = {
    val add = (a: Int, b: Int) => a + b
    val curriedAdd = add.curried
    println(curriedAdd(3)(4))
  }
}

Deshacer la currificación

El auxiliar Function.uncurried invierte el proceso y convierte una función currificada en otra con una sola lista de parámetros.

object Main {
  def main(args: Array[String]): Unit = {
    val curried: Int => Int => Int = a => b => a + b
    val normal = Function.uncurried(curried)
    println(normal(3, 4))
  }
}

Por qué resulta útil la currificación

La currificación permite reutilizar código: fija los primeros argumentos una vez y después llama al resultado muchas veces con distintos argumentos restantes. También ayuda al compilador a inferir los tipos de las listas posteriores.

object Main {
  def discount(rate: Double)(price: Double): Double = price * (1 - rate)
  def main(args: Array[String]): Unit = {
    val blackFriday = discount(0.3) _
    println(blackFriday(100))
    println(blackFriday(250))
  }
}

Inferencia de tipos en la última lista

Una razón práctica para usar varias listas de parámetros es que el compilador puede inferir los tipos de los parámetros de la lambda a partir de las listas anteriores, por lo que puede omitirlos.

object Main {
  def fold[A](xs: List[A])(init: A)(op: (A, A) => A): A =
    xs.foldLeft(init)(op)
  def main(args: Array[String]): Unit = {
    val total = fold(List(1, 2, 3))(0)((a, b) => a + b)
    println(total)
  }
}

Currificación con tres listas

Puede tener tantas listas de parámetros como quiera. Cada llamada proporciona una lista y devuelve una función para la siguiente.

object Main {
  def make(a: Int)(b: Int)(c: Int): Int = a + b + c
  def main(args: Array[String]): Unit = {
    println(make(1)(2)(3))
    val step = make(10) _
    println(step(20)(30))
  }
}

Crear validadores configurables

Un uso habitual en situaciones reales es currificar una regla de validación, fijar el umbral y reutilizar el predicado resultante en un conjunto de datos.

object Main {
  def atLeast(min: Int)(value: Int): Boolean = value >= min
  def main(args: Array[String]): Unit = {
    val adult = atLeast(18) _
    println(List(15, 21, 18, 12).map(adult))
  }
}

Currificación frente a aplicación parcial

La currificación es la transformación estructural en funciones de un argumento. La aplicación parcial consiste en proporcionar algunos argumentos ahora y el resto más adelante. Las funciones currificadas hacen natural la aplicación parcial.

object Main {
  def greet(greeting: String)(name: String): String = s"$greeting, $name!"
  def main(args: Array[String]): Unit = {
    val sayHi = greet("Hi") _
    println(sayHi("Ann"))
    println(sayHi("Bob"))
  }
}

Comprobación rápida

¿Cómo se define un método currificado en Scala?

Repaso

Ha aprendido sobre la currificación y la aplicación parcial:

Los métodos currificados usan varias listas de parámetros: f(a)(b)
Aplique parcialmente con f(x) _ para obtener una función nueva
.curried y Function.uncurried convierten entre ambas formas
Ayudan a reutilizar, especializar e inferir tipos

Preguntas frecuentes

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

Sí — el texto completo de «Currificació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 «Currificación»?

Aplicación parcial 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 2 de 4.

¿Cuánto tiempo toma la lección «Currificació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