Currying is a technique in functional programming where a function with multiple arguments is transformed into a sequence of functions, each taking a single argument. This improves composability and allows partial application of functions.
function add(x) {
return function(y) {
return x + y;
};
}
const addTwo = add(2);
console.log(addTwo(3)); // Output: 5
2. sum(2)(6)(1)
This function demonstrates currying by taking three separate arguments and adding them together in a sequence using nested functions.
function sum(x) {
return function(y) {
return function(z) {
return x + y + z;
};
};
}
console.log(sum(2)(6)(1)); // Output: 9
4. Write a currying function evaluate("sum")(4)(2)
This question showcases a curried function evaluate that takes an operation string and two numbers, then performs the corresponding operation (sum, multiply, divide, subtract) based on the string input.
function evaluate(operation) {
return function(x) {
return function(y) {
switch (operation) {
case 'sum':
return x + y;
case 'multiply':
return x * y;
case 'divide':
return x / y;
case 'subtract':
return x - y;
default:
return NaN;
}
};
};
}
console.log(evaluate('sum')(4)(2)); // Output: 6
5. Infinite Currying -> sum(1)(2)(3)....(n)
This example illustrates how currying can be used recursively to handle an indefinite number of arguments, continually adding them together until a termination condition is met.
function sumNumbers(x) {
let sum = x;
function inner(y) {
sum += y;
return inner;
}
inner.toString = function() {
return sum;
};
return inner;
}
console.log(sumNumbers(1)(2)(3)); // Output: 6
console.log(sumNumbers(1)(2)(3)(4)(5)); // Output: 15
6. Currying vs Partial Application
This question compares currying and partial application, showing how currying allows for creating reusable functions with specific arguments filled in, while partial application involves pre-filling some arguments and leaving others for later.
Currying Example:
function multiply(a) {
return function(b) {
return a * b;
};
}
const multiplyByTwo = multiply(2);
console.log(multiplyByTwo(5)); // Output: 10
Partial Application Example:
function greet(greeting, name) {
return greeting + ', ' + name + '!';
}
const greetHello = greet.bind(null, 'Hello');
console.log(greetHello('John')); // Output: Hello, John!
7. Real-world example of currying => Manipulating DOM
In this example, currying is used to create a function that updates the text content of an HTML element identified by its ID. This showcases a practical application of currying in web development for DOM manipulation.
function updateElementContentById(id) {
return function(content) {
const element = document.getElementById(id);
if (element) {
element.textContent = content;
} else {
console.error('Element with id ' + id + ' not found.');
}
};
}
// Usage
const updateTitle = updateElementContentById('title');
updateTitle('New Title');
8. Curry() implementation
This code snippet demonstrates a custom implementation of the curry function, which transforms a multi-argument function into a curried function, enabling partial application and composability. It's applied to a simple sum function for demonstration.
// Custom curry function implementation
function curry(func) {
return function curried(...args) {
if (args.length >= func.length) {
return func.apply(this, args);
} else {
return function(...moreArgs) {
return curried.apply(this, args.concat(moreArgs));
};
}
};
}
// Example usage
function simpleSum(a, b, c) {
return a + b + c;
}
const curriedSum = curry(simpleSum);
console.log(curriedSum(1)(2)(3)); // Output: 6
console.log(curriedSum(1, 2)(3)); // Output: 6
console.log(curriedSum(1)(2, 3)); // Output: 6
console.log(curriedSum(1, 2, 3)); // Output: 6