Curry Function with Placeholder in JavaScript

Currying is a technique that transforms a function with multiple arguments into a sequence of functions, each taking a single argument. This challenge asks you to implement a curried function in JavaScript that also supports placeholders. Placeholders allow you to pre-fill some arguments, creating a partially applied function that can be further specialized later. This is useful for creating reusable functions with default values or for building function pipelines.

Problem Description

You need to implement a curryWithPlaceholder function that takes a function and an optional number of placeholder arguments. The function should return a new function that, when called with the remaining arguments, will execute the original function with the combined placeholder and provided arguments.

What needs to be achieved:

• Create a function curryWithPlaceholder(func, ...placeholders) that returns a new function.
• The returned function should accept arguments one at a time.
• If the number of arguments provided matches the number of placeholders, the original function func should be called with the combined arguments.
• If fewer arguments are provided than placeholders, the returned function should continue to accept arguments until all placeholders are filled.

Key Requirements:

• The curryWithPlaceholder function should handle an arbitrary number of placeholder arguments.
• The order of arguments matters.
• The original function func should be called with the correct arguments in the correct order.

Expected Behavior:

The returned function should behave like a curried function, but with the added ability to pre-fill some arguments using placeholders.

Edge Cases to Consider:

• What happens if the original function func takes no arguments?
• What happens if the number of arguments provided is greater than the number of placeholders? (Should throw an error or handle gracefully - your choice, but document it).
• What happens if func is not a function? (Should throw an error).
• What happens if the placeholders are not provided? (Should behave like a standard curry function).

Examples

Example 1:

Input: curryWithPlaceholder((x, y) => x + y, 5)
Output: (y) => 5 + y
Explanation: The original function (x, y) => x + y is partially applied with x = 5. The returned function now expects only the 'y' argument.

Example 2:

Input: curryWithPlaceholder((x, y, z) => x * y + z, 2, 3)
Output: (z) => 2 * 3 + z
Explanation: The original function (x, y, z) => x * y + z is partially applied with x = 2 and y = 3. The returned function now expects only the 'z' argument.

Example 3:

Input: curryWithPlaceholder((x, y, z) => x * y + z, 2, 3)(4)
Output: 10
Explanation: The original function (x, y, z) => x * y + z is called with x = 2, y = 3, and z = 4, resulting in 2 * 3 + 4 = 10.

Example 4:

Input: curryWithPlaceholder((x, y) => x + y)
Output: (x) => (y) => x + y
Explanation:  Standard curry behavior when no placeholders are provided.

Constraints

• The func argument must be a function. If not, throw a TypeError.
• The number of arguments passed to the final curried function should not exceed the number of arguments func expects. If it does, throw a RangeError.
• The function should be able to handle functions with zero or more arguments.
• The solution should be reasonably performant (avoid unnecessary object creation or complex operations).

Notes

Consider using closures to maintain the state of the placeholder arguments. Think about how to handle the case where the original function is called with fewer arguments than it expects. The key is to return a function that continues to accept arguments until all placeholders and required arguments are provided. You can use the arguments object or the rest parameter (...args) to handle the variable number of arguments.