Qué es el Currying en JavaScript

El currying es una técnica que transforma una función con múltiples parámetros en una secuencia de funciones, cada una con un solo parámetro.

En otras palabras, en lugar de pasar todos los argumentos a la función de una vez, el currying permite “descomponer” la función en pasos más simples.

El currying es un concepto proviene del ámbito matemático, y que ha encontrado un lugar importante en la programación funcional. En JavaScript, se ha vuelto un patrón muy popular.

Currying en JavaScript

Para ilustrar el currying, supongamos un ejemplo sencillo. Imaginemos que tenemos una función simple que suma dos números:

function sumar(a, b) {
    return a + b;
}

¿Nada especialmente llamativo, verdad? Veamos la versión curried de esta funcion.

function sumarCurried(a) {
    return function(b) {
        return a + b;
    };
}

Ahora, en lugar de llamar a nuestra funcion sumar(a, b), tenemos una función que acepta un parámetro, y devuelve otra función que acepta otro parámetro.

Podemos utilizar nuestra versión sumarCurried de la siguiente manera:

const sumar5 = sumarCurried(5);

console.log(sumar5(3));  // Output: 8
console.log(sumar5(10)); // Output: 15

Currying con lambdas

Podemos usar funciones lambda para crear una versión más compacta de currying. El comportamiento sigue siendo el mismo, pero el uso de lambdas lo hace más conciso y más acorde con el estilo moderno de JavaScript.

const sumar = a => b => a + b + c;

const resultado = sumar(2)(3); // Resultado: 5

Implementación de Currying

Hemos visto como convertir una función en una versión “curried” de forma manual, en el ejemplo anterior con la función suma.

Sin embargo, lo normal es que hagamos alguna solución genérica, para convertir cualquier función. Vamos a ver alguna de ellas.

function currying(fn) {
    return function(arg1) {
        return function(arg2) {
            return fn(arg1, arg2);
        };
    };
}

// Uso
function multiplicar(a, b) {
    return a * b;
}

const multiplicarCurried = currying(multiplicar);
const multiplicarPor2 = multiplicarCurried(2);
console.log(multiplicarPor2(4)); // Output: 8

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

// Uso
function multiplicar(a, b, c) {
    return a * b * c;
}

const multiplicarCurried = currying(multiplicar);
const multiplicarPor2y3 = multiplicarCurried(2)(3);
console.log(multiplicarPor2y3(4)); // Output: 24

const _ = require('lodash');

const curriedSum = _.curry(function(a, b, c) {
    return a + b + c;
});

console.log(curriedSum(1)(2)(3)); // 6

Composición de funciones

El currying y la composición de funciones están estrechamente relacionados. Mientras que el currying descompone funciones en una serie de funciones unarias, la composición de funciones permite combinarlas para construir nuevas funciones más complejas.

const sumar = a => b => a + b;
const multiplicar = a => b => a * b;

// Combinamos las funciones para crear una nueva
const sumaMultiplicada = (a, b, c) => multiplicar(a)(sumar(b)(c));

console.log(sumaMultiplicada(2, 3, 4)); // Output: 14

Es decir, hemos compuesto dos funciones curried (sumar y multiplicar) para formar una nueva función más compleja (sumaMultiplicada)

Ejemplos prácticos

function descuento(porcentaje) {
  return function(precio) {
    return precio * (1 - porcentaje);
  };
}

const aplicarDescuento10 = descuento(0.1);
const aplicarDescuento20 = descuento(0.2);

console.log(aplicarDescuento10(100)); // Resultado: 90
console.log(aplicarDescuento20(100)); // Resultado: 80

function configurarSaludo(saludo) {
    return function(nombre) {
        return `${saludo}, ${nombre}!`;
    };
}

const saludoFormal = configurarSaludo('Buenos días');
console.log(saludoFormal('Juan')); // Buenos días, Juan!

function sumar(a, b) {
    return a + b;
}

function multiplicar(a, b) {
    return a * b;
}

const curriedSum = currying(sumar);
const curriedMultiply = currying(multiplicar);

const resultado = curriedMultiply(curriedSum(2)(3))(4);
console.log(resultado); // 20