11. Currying, Partial Application & Function Composition (Pipe/Compose) • JavaScript & Advanced ES6+ (0-to-Hero Big Tech Standard) • Rishabh Ki Kaksha

**Currying ek aisa functional programming technique hai** jisme multiple arguments lene wale function `f(a, b, c)` ko ek-ek argument lene wale functions ki chain `f(a)(b)(c)` me tod diya jata hai.

**Tagline yaad rakh:**
> Normal: Ek hi baar me 3 roti khana `eat(roti1, roti2, roti3)`  
> Currying: Ek-ek nivala karke khana `eat(roti1)(roti2)(roti3)`

---

### 2. Currying vs Partial Application

```javascript
// Normal Function
function add(a, b, c) {
    return a + b + c;
}

// 1. Curried Function (Har step par single argument lega jab tak sab na mil jayein)
function curriedAdd(a) {
    return function(b) {
        return function(c) {
            return a + b + c;
        };
    };
}
console.log(curriedAdd(1)(2)(3)); // 6

// 2. Partial Application (Kuch arguments pehle se fix kar dena)
const add5 = add.bind(null, 5); // 'a' ki value 5 fix kar di
console.log(add5(10, 20)); // 35
```

---

### 3. Infinite Currying (FAANG's Favorite Coding Question)

Sawal: Ek aisa `add` function banao jo kitni bhi baar call ho sake: `add(1)(2)(3)(4)...()`

```javascript
function infiniteAdd(a) {
    return function(b) {
        if (b !== undefined) {
            return infiniteAdd(a + b); // Keep recurring
        }
        return a; // Terminate when called with ()
    };
}

console.log(infiniteAdd(1)(2)(3)());           // 6
console.log(infiniteAdd(10)(20)(30)(40)(50)()); // 150
```

---

### 4. Function Composition: `pipe()` vs `compose()`

Jab tujhe ek data par 3-4 transformations ek sath lagane hon (Jaise: String lo ➔ Trim karo ➔ Lowercase karo ➔ Slug banao):

*   **`pipe()` (Left to Right):** Data pehle function 1 se gujarega, fir 2, fir 3 (`f1 ➔ f2 ➔ f3`).
*   **`compose()` (Right to Left):** Mathematics style `f(g(h(x)))`.

```javascript
// Pure Utility Functions
const trim = str => str.trim();
const toLower = str => str.toLowerCase();
const replaceSpaces = str => str.replace(/\s+/g, '-');

// Generic Pipe Implementation (Big Tech Utility)
const pipe = (...functions) => (initialValue) =>
    functions.reduce((currentValue, fn) => fn(currentValue), initialValue);

// Building our Pipeline
const createSlug = pipe(trim, toLower, replaceSpaces);

console.log(createSlug("  JavaScript Mastery Course 2026!  ")); 
// Output: "javascript-mastery-course-2026!"
```

---

### 5. Comparison Table: Currying vs Compose vs Pipe

---

### 6. Interview Ke 3 Sawal Is Topic Se

1. **Currying ka practical benefit kya hai?** -> Code reusability badhata hai (jaise ek `logger(type)(module)(message)` bana kar `const errorLog = logger('ERROR')('AUTH')` reusable utility bana sakte hain).
2. **Arity kya hoti hai?** -> Kisi function ke parameters ki total count ko uski "Arity" kehte hain (e.g. 2 params = Binary function, 1 param = Unary).
3. **`reduce()` se pipe kaise banta hai?** -> Initial value ko har function se pass karte huye accumulator me updated output store karte hain.

---
**Next Topic:** 12. Method Borrowing: call(), apply(), bind() & Custom Polyfills

Loading lesson content...

🎯 Big Tech Coding & Interview Challenges

Practice these curated problems. Click "Load in Sandbox" to solve live in the Code Studio!

1 Questions

Medium

1. Infinite Currying Accumulator

Implement an infinite currying accumulator function `add` such that `add(1)(2)(3)() === 6` and `add(10)(20)() === 30`.

💡 View Pro Interview Hint

• Return the recursive function until called with empty parentheses.

JavaScript

Full IDE

Live Execution Terminal

Click "Execute Live" to run code.
                

🎯 Big Tech Coding & Interview Challenges

1. Infinite Currying Accumulator

Lesson Mastery AI Quiz

AI Doubt Solver

CERTIFICATE OF COMPLETION

Rishabh Gehlot

PHP 8+ & Laravel 11 Master Track