Implement a Curried Function in JavaScript

Currying is a functional programming technique that transforms a function taking multiple arguments into a sequence of functions, each taking a single argument. This allows for partial application of functions, leading to more declarative and reusable code. Your challenge is to implement a curry function in JavaScript that can take any function and return its curried version.

Problem Description

You need to create a JavaScript function named curry that accepts another function as its argument. The curry function should return a new function. This new function, when called, should behave as follows:

1. If the number of arguments provided to the curried function is less than the number of arguments expected by the original function, it should return another function that waits for the remaining arguments.
2. If the number of arguments provided is sufficient to call the original function, it should execute the original function with all the collected arguments and return its result.

The curry function should be able to handle functions with any number of arguments.

Key Requirements:

• The curry function must accept a single argument: the function to be curried.
• The returned curried function should collect arguments progressively.
• The original function should be invoked only when all its required arguments have been supplied.
• The curried function should accept an arbitrary number of arguments in each call.

Expected Behavior:

When curry(fn) is called, it returns a new function. Let's call this curriedFn. curriedFn can be called multiple times, accumulating arguments. When the total number of accumulated arguments equals or exceeds the expected number of arguments for fn, fn is called with the accumulated arguments, and its return value is returned.

Edge Cases:

• Functions with zero arguments: The curried version should immediately return the result of the original function.
• Functions with a large number of arguments.

Examples

Example 1:

function sum(a, b, c) {
  return a + b + c;
}

const curriedSum = curry(sum);

const result1 = curriedSum(1)(2)(3); // Calls sum(1, 2, 3)
console.log(result1); // Output: 6

const result2 = curriedSum(1, 2)(3); // Calls sum(1, 2, 3)
console.log(result2); // Output: 6

const result3 = curriedSum(1)(2, 3); // Calls sum(1, 2, 3)
console.log(result3); // Output: 6

const result4 = curriedSum(1, 2, 3); // Calls sum(1, 2, 3)
console.log(result4); // Output: 6

Explanation: The curry function takes the sum function. It returns curriedSum. Each call to curriedSum can provide some or all of the arguments. curriedSum waits until it has received three arguments in total before calling the original sum function.

Example 2:

function greet(greeting, name, punctuation) {
  return `${greeting}, ${name}${punctuation}`;
}

const curriedGreet = curry(greet);

const sayHelloToBob = curriedGreet("Hello", "Bob");
const sayHelloToBobExclamation = sayHelloToBob("!");
console.log(sayHelloToBobExclamation); // Output: Hello, Bob!

const sayHiToAlice = curriedGreet("Hi", "Alice")("?");
console.log(sayHiToAlice); // Output: Hi, Alice?

Explanation: Demonstrates how currying can be used for partial application. We create a reusable sayHelloToBob function by fixing the greeting and name arguments.

Example 3:

function identity(x) {
  return x;
}

const curriedIdentity = curry(identity);
const result = curriedIdentity(10);
console.log(result); // Output: 10

function noArgs() {
  return "no arguments passed";
}

const curriedNoArgs = curry(noArgs);
const resultNoArgs = curriedNoArgs();
console.log(resultNoArgs); // Output: no arguments passed

Explanation: Handles a function with one argument (identity) and a function with zero arguments (noArgs). The zero-argument function is executed immediately upon the first call to its curried version.

Constraints

• The original function (fn) will be a valid JavaScript function.
• The curry function should be able to handle functions with any number of arguments, including zero.
• The implementation should be efficient and avoid unnecessary overhead.
• The solution must be written in JavaScript.

Notes

• Consider how to determine the number of arguments the original function expects. The length property of a function object can be helpful here.
• Think about how to accumulate arguments across multiple calls.
• Be mindful of how you handle the final invocation of the original function.
• You are not expected to handle variadic functions (functions that accept an indefinite number of arguments using ...args) in a way that dynamically adjusts the expected argument count based on usage. The length property of the function is the definitive count.