El curry es un concepto poderoso en programación funcional que transforma una función con múltiples argumentos en una secuencia de funciones, cada una de las cuales toma un solo argumento. Esta técnica permite un código más modular y reutilizable. En JavaScript, el curry se puede implementar de varias maneras. Este blog explorará el curry, proporcionará ejemplos y analizará diferentes métodos para lograr el curry con n argumentos.

¿Qué es el curry?

Currying es el proceso de convertir una función que toma múltiples argumentos en una serie de funciones que toman cada una un solo argumento. Por ejemplo, una función f(a, b, c) se puede transformar en f(a)(b)(c).

¿Por qué utilizar curry?

• Aplicación parcial: Currying te permite corregir algunos argumentos de una función y crear una nueva función.
• Funciones de orden superior: Facilita el uso de funciones de orden superior, que toman otras funciones como argumentos o las devuelven.
• Reutilizabilidad del código: las funciones curadas son más reutilizables y componibles.
• Composición funcional: El curry permite una mejor composición funcional, donde las funciones complejas se construyen combinando funciones más simples, lo que genera un código más limpio y fácil de mantener.

Ejemplo de curry simple

Comencemos con un ejemplo básico para entender cómo funciona el curry.

Función no currida

Aquí hay una función simple que suma tres números:

function add(a, b, c) {
  return a   b   c;
}

console.log(add(1, 2, 3)); // Output: 6

Explicación: Esta función agregar toma tres argumentos a, byc, y devuelve su suma. Cuando llamamos a agregar (1, 2, 3), devuelve 6.

Función de curry

Ahora, conviertamos esta función a una versión con curry:

function curryAdd(a) {
  return function(b) {
    return function(c) {
      return a   b   c;
    };
  };
}

console.log(curryAdd(1)(2)(3)); // Output: 6

Explicación: La función curryAdd toma un argumento a y devuelve una función que toma un argumento b, que a su vez devuelve una función que toma un argumento c. La función final devuelve la suma de a, b y c. Cuando llamamos a curryAdd(1)(2)(3), pasa secuencialmente los argumentos 1, 2 y 3 a través de las funciones anidadas, lo que da como resultado 6.

Curry con funciones de flecha

Las funciones de flecha de JavaScript proporcionan una forma concisa de crear funciones curry.

const curryAddArrow = a => b => c => a   b   c;

console.log(curryAddArrow(1)(2)(3)); // Output: 6

Explicación: La función curryAddArrow es una función de flecha que toma un argumento a y devuelve otra función de flecha que toma b, que devuelve otra función de flecha que toma c. La función de flecha final devuelve la suma de a, b y c. Cuando llamamos a curryAddArrow(1)(2)(3), pasa secuencialmente los argumentos 1, 2 y 3 a través de las funciones de flecha anidadas, lo que da como resultado 6.

Caso de uso

1.Funciones de configuración

Un caso de uso común para el curry son las funciones de configuración. Por ejemplo, imagine que está creando una utilidad de registro en la que desea configurar el nivel de registro y el formato del mensaje por separado.

function logger(level) {
  return function (message) {
    console.log(`[${level}] ${message}`);
  };
}

const infoLogger = logger('INFO');
const errorLogger = logger('ERROR');

infoLogger('This is an info message');
errorLogger('This is an error message');

2. Formateador de cadenas

Consideremos un ejemplo práctico en el que se puede utilizar el curry para crear un formateador de cadenas. Este formateador le permitirá configurar el prefijo y el sufijo por separado.

function formatter(prefix) {
  return function (suffix) {
    return function (str) {
      return `${prefix}${str}${suffix}`;
    };
  };
}

const htmlFormatter = formatter('')('');
console.log(htmlFormatter('Hello')); // Hello

const parensFormatter = formatter('(')(')');
console.log(parensFormatter('123')); // (123)

Curry en bibliotecas modernas de JavaScript

El curry se usa comúnmente en bibliotecas modernas de JavaScript como Lodash y Ramda. Por ejemplo, en Lodash, puedes usar el método _.curry para crear funciones con curry fácilmente.

const _ = require('lodash');

function multiply(a, b, c) {
  return a * b * c;
}

const curriedMultiply = _.curry(multiply);

console.log(curriedMultiply(2)(3)(4)); // 24
console.log(curriedMultiply(2, 3)(4)); // 24

Curry con N argumentos

Veamos el siguiente ejemplo de curry con una función recursiva que agrega n argumentos. Usaremos curry para crear una función que pueda aceptar cualquier cantidad de argumentos, uno a la vez, y sumarlos.

function curryAddition(fn) {
  return function curried(...args) {
    if (args.length >= fn.length) {
      return fn(...args);
    } else {
      return function(...nextArgs) {
        return curried(...args, ...nextArgs);
      };
    }
  };
}

// This function sums an array of numbers
function add(...nums) {
  return nums.reduce((acc, num) => acc   num, 0);
}

// Creating a curried version of the addition function
const curriedAdd = curryAddition(add);

// Function to handle n arguments
function curriedAddN(...initialArgs) {
  function adder(...args) {
    if (args.length === 0) {
      return curriedAdd(...initialArgs);
    }
    initialArgs.push(...args);
    return adder;
  }
  return adder;
}

// Examples
const addFiveNumbers = curriedAddN();
console.log(addFiveNumbers(1)(2)(3)(4)(5)()); // 15

const addThreeNumbers = curriedAddN(1)(2)(3);
console.log(addThreeNumbers()); // 6

const addNumbersInSteps = curriedAddN(1, 2)(3)(4, 5);
console.log(addNumbersInSteps()); // 15

Conclusión

El curry es una técnica poderosa en programación funcional que mejora la modularidad y la reutilización del código. Al transformar funciones en cadenas de funciones de un solo argumento, el curry permite una aplicación parcial y una composición de funciones flexible. Ya sea para configuración, formato de cadenas o cálculos complejos, el curry puede hacer que su código sea más expresivo y adaptable.