Currying மற்றும் partial application என்றால் என்ன?

Question

Accepted Answer

**Currying** என்பது N arguments எடுக்கும் ஒரு function ஐ N functions களின் chain ஆக மாற்றுகிறது, ஒவ்வொன்றும் ஒரு argument எடுக்கிறது. **Partial application** என்பது *சில* arguments ஐ இப்போது fix செய்து, மீதமுள்ளவற்றுக்காக காத்திருக்கும் function ஐ return செய்கிறது.

```js
// normal
const add = (a, b, c) => a + b + c;

// curried — one argument at a time
const curriedAdd = a => b => c => a + b + c;
curriedAdd(1)(2)(3); // 6

// partial application — pre-fill some args
const add10 = curriedAdd(10);   // a is fixed at 10
add10(5)(1);                     // 16
```

ஒவ்வொரு step ம் ஒரு **closure** ஐப் பயன்படுத்தி முந்தைய arguments ஐ நினைவில் வைத்திருக்கிறது, இதுவரை அனைத்தும் supply செய்யப்பட்டுவிடும் வரை.

## பயனுள்ளவை ஏன்: specialized functions ஐ build செய்தல்

```js
const log = level => message => console.log(`[${level}] ${message}`);
const error = log("ERROR");   // reusable, pre-configured logger
const info = log("INFO");
error("disk full");           // [ERROR] disk full
```

நிலைமையை எல்லா இடத்திலும் repeat செய்ய பதிலாக, நீங்கள் configured functions ஐ ஒரு முறை create செய்கிறீர்கள். இது functional pipelines மற்றும் event handlers ல் luminous அடிப்படையில் வேலை செய்கிறது:

```js
const onChange = field => e => setForm(f => ({ ...f, [field]: e.target.value }));
<input onChange={onChange("email")} />  // a handler specialized to "email"
```

## Generic curry / libraries

Libraries (Ramda, lodash `curry`) எந்த function க்கும் auto-curry செய்கிறது, அதனால் நீங்கள் arguments ஐ flexible groups ல் supply செய்யலாம்.

## ஏன் முக்கியம்

Currying clean **function composition**, reusable configured callbacks, மற்றும் point-free style ஐ enable செய்கிறது.

இது functional codebases ல் common ஆகவும், closures ஐ புரிந்துகொள்வதை test செய்ய அடிக்கடி interview topic ஆகவும் உள்ளது.