Currying మరియు partial application అంటే ఏమిటి?

Question

Accepted Answer

**Currying** అనేది N arguments తీసుకునే ఒక function ను N functions ల చైన్‌గా మార్చుతుంది, ఆ విధంగా ఒక్కొక్కటి ఒక 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
```

ప్రతి దశ ఒక **closure** ను ఉపయోగించి మునుపటి arguments ను గుర్తుపెట్టుకుంటుంది, అన్నీ సరఫరా చేయబడే వరకు.

## ఉపయోగకరమైనది ఎందుకు: specialized functions ను నిర్మించడం

```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
```

ప్రతిచోటా level ను పునరావృత్తి చేయడానికి బదులుగా, మీరు configured functions ను ఒకసారి సృష్టిస్తారు. ఇది functional pipelines మరియు event handlers లో మెరుస్తుంది:

```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 లలో సరఫరా చేయవచ్చు.

## ఇది ఎందుకు ముఖ్యమైనది

Currying clean **function composition**, reusable configured callbacks, మరియు point-free style ను ఎనేబుల్ చేస్తుంది.

ఇది functional codebases లో సాధారణమైనది మరియు closures ల అవగతను పరీక్షించడానికి సాధారణ interview topic.