Chapter 45 — Currying & Function Composition

Bu bobda funksional dasturlashning ikkita kuchli texnikasi — Currying va Function Compositionni o'rganamiz. Ular Chapter 12 (Closures) va Chapter 14 (Higher-Order Functions) bilimlariga asoslanadi.

---

45.1 Currying nima?

Simple Explanation

Currying — bir nechta argument qabul qiluvchi functionni, har safar bitta argument qabul qiluvchi function'lar zanjiriga aylantirish texnikasi.

Real-Life Analogy

☕️ Currying'ni bosqichma-bosqich buyurtma berishga o'xshating: kofe hajmini tanlaysiz, keyin turini tanlaysiz, keyin shakar miqdorini tanlaysiz — har bir tanlov alohida "qadam", va faqat barcha tanlovlar tugagach, yakuniy kofe (natija) tayyor bo'ladi.

Oddiy function vs Curried function

script.js
JavaScriptNusxalash
01// Oddiy function
02function add(a, b, c) {
03    return a + b + c;
04}
05 
06console.log(add(1, 2, 3)); // 6
07 
08// Curried function
09function curriedAdd(a) {
10    return function (b) {
11        return function (c) {
12            return a + b + c;
13        };
14    };
15}
16 
17console.log(curriedAdd(1)(2)(3)); // 6

Explanation

curriedAdd(1) — b argumentini kutayotgan yangi function qaytaradi. curriedAdd(1)(2) — c argumentini kutayotgan yana bir function qaytaradi. Faqat uchinchi chaqiruv ((3)) — yakuniy natijani beradi.

🔗 Connection
Bu — Chapter 12'da o'rgangan createMultiplier misolining kengaytirilgan ko'rinishi: har bir ichki function — closure orqali tashqi argumentlarni "eslab qoladi".

45.2 ⚠️ Qiyin mavzu: Nima uchun Currying foydali?

Simple Explanation

Currying'ning asosiy foydasi — qisman qo'llash (partial application): ba'zi argumentlarni oldindan "belgilab qo'yib", keyinroq faqat qolganlarini berish.

Amaliy misol — moslashtirilgan function'lar yaratish

script.js
JavaScriptNusxalash
01function multiply(a) {
02    return function (b) {
03        return a * b;
04    };
05}
06 
07let double = multiply(2);
08let triple = multiply(3);
09 
10console.log(double(5)); // 10
11console.log(triple(5)); // 15

Explanation

multiply(2) — a = 2ni "eslab qolgan", faqat bni kutayotgan yangi function (double) yaratadi. Bu — Chapter 14'da ko'rgan createMultiplier bilan bir xil, faqat endi buni "Currying" atamasi bilan tushunayapmiz.

Real loyihadagi amaliy misol — logging

script.js
JavaScriptNusxalash
01function log(level) {
02    return function (message) {
03        console.log(`[${level.toUpperCase()}] ${message}`);
04    };
05}
06 
07let logError = log("error");
08let logInfo = log("info");
09 
10logError("Fayl topilmadi");  // "[ERROR] Fayl topilmadi"
11logInfo("Dastur ishga tushdi"); // "[INFO] Dastur ishga tushdi"

💡 Key Idea
Currying — bir xil "asosiy mantiq"ga ega, lekin turli "sozlamalar" bilan ishlaydigan function'larni yaratishning ixcham usuli.

45.3 Umumiy (Universal) Curry Function

Simple Explanation

Har safar qo'lda ichma-ich function yozish o'rniga, istalgan functionni avtomatik "curry qiladigan" umumiy HOF yozish mumkin.

Example

script.js
JavaScriptNusxalash
01function curry(func) {
02    return function curried(...args) {
03        if (args.length >= func.length) {
04            return func.apply(this, args);
05        } else {
06            return function (...moreArgs) {
07                return curried.apply(this, args.concat(moreArgs));
08            };
09        }
10    };
11}
12 
13function sum(a, b, c) {
14    return a + b + c;
15}
16 
17let curriedSum = curry(sum);
18 
19console.log(curriedSum(1, 2, 3)); // 6 — barchasi birga
20console.log(curriedSum(1)(2)(3)); // 6 — birma-bir
21console.log(curriedSum(1, 2)(3)); // 6 — aralash

How It Works

1. func.length — Chapter 6'dan ma'lum: bu function e'lon qilingandagi parametrlar sonini bildiradi (bu — function'ning maxsus propertysi).
2. Agar hozirgacha yig'ilgan argumentlar soni (args.length) — kerakli sondan (func.length) kam bo'lsa, yana argument kutuvchi yangi function qaytariladi.
3. Yetarli argument to'planganda, asl func chaqiriladi.

🔥 Important
Bu — Currying'ning eng moslashuvchan shakli: u argumentlarni istalgan tartibda (birma-bir, guruh-guruh, yoki barchasini birga) qabul qilishga imkon beradi.

45.4 ⚠️ Qiyin mavzu: Function Composition

Simple Explanation

Function Composition — bir nechta kichik function'ni birlashtirib, ularning natijasi ketma-ket bir-biriga "uzatiladigan" yagona, kattaroq function yaratish.

Real-Life Analogy

🏭 Function Composition — bu ishlab chiqarish konveyeri: xomashyo birinchi stansiyadan o'tadi, uning natijasi ikkinchi stansiyaga uzatiladi, va hokazo — har bir stansiya oldingisining natijasi ustida ishlaydi.

Muammoli misol — qo'lda zanjirlash

script.js
JavaScriptNusxalash
01function double(x) {
02    return x * 2;
03}
04 
05function increment(x) {
06    return x + 1;
07}
08 
09function square(x) {
10    return x * x;
11}
12 
13let result = square(increment(double(5)));
14// double(5) = 10 → increment(10) = 11 → square(11) = 121
15 
16console.log(result); // 121

Muammo: square(increment(double(5))) — o'qish uchun "ichkaridan tashqariga" o'qilishi kerak, bu tabiiy o'qish yo'nalishiga (chapdan o'ngga) zid.

Yechim — Umumiy compose Function

script.js
JavaScriptNusxalash
01function compose(...funcs) {
02    return function (initialValue) {
03        return funcs.reduceRight((acc, func) => func(acc), initialValue);
04    };
05}
06 
07let transform = compose(square, increment, double);
08 
09console.log(transform(5)); // 121 (xuddi yuqoridagi kabi)

How It Works — bosqichma-bosqich

1. compose(square, increment, double) — 3 ta functionni argument sifatida qabul qiladi (Chapter 6'dagi rest parameters).
2. reduceRight() — Chapter 15'dagi reduce()ga o'xshaydi, lekin o'ngdan chapga ishlaydi.
3. Boshlang'ich qiymat (5) — eng o'ngdagi function'dan (double) boshlab, ketma-ket chapga qarab ishlov beriladi: double(5)=10 → increment(10)=11 → square(11)=121.

🔗 Connection
Bu — Chapter 15'da o'rgangan reduce()ning ilg'or, amaliy qo'llanilishi: bir nechta function'ni "yig'ib", bitta yakuniy natijaga keltirish.

pipe() — teskari yo'nalishdagi composition

script.js
JavaScriptNusxalash
01function pipe(...funcs) {
02    return function (initialValue) {
03        return funcs.reduce((acc, func) => func(acc), initialValue);
04    };
05}
06 
07let transform2 = pipe(double, increment, square);
08 
09console.log(transform2(5)); // 121 — xuddi shu natija, lekin O'QISH TARTIBI chapdan o'ngga!

Explanation

pipe() — oddiy reduce() (chapdan o'ngga) ishlatadi, shuning uchun function'lar yozilgan tartibda (chapdan o'ngga) bajariladi — bu ko'pchilik uchun tabiiyroq o'qiladi.

⚠️ Common Mistake
compose va pipeni farqlash — ular bir xil natija berishi mumkin, lekin function'larning yozilish tartibi (o'ngdan chapga vs chapdan o'ngga) farq qiladi. Loyihada qaysi biri ishlatilishidan qat'iy nazar, jamoa ichida bir xil konventsiyaga rioya qilish muhim.

📝 Practice Exercises

🟢 Exercise 1 — Easy

Task:
curriedMultiply(a)(b)(c) — uch sonni ko'paytiruvchi curried function yozing (qo'lda, ichma-ich function orqali, Chapter 45.1'dagi kabi).
Required Concepts:

• Manual currying
  Hint:
  function curriedMultiply(a) { return b => c => a * b * c; }

🟡 Exercise 2 — Medium

Task:
Chapter 45.3'dagi umumiy curry() functionidan foydalanib, volume(length, width, height) (uchta o'lchamning ko'paytmasi) functionini curry qiling va uni turli usullarda (volume(2)(3)(4), volume(2, 3)(4), volume(2, 3, 4)) chaqirib sinab ko'ring.
Required Concepts:

• Universal curry()
  Hint:
  Chapter 45.3'dagi misolga o'xshab yozing.

🔴 Exercise 3 — Hard

Task:
Chapter 45.4'dagi pipe() functionidan foydalanib, matnni qayta ishlovchi 3 ta kichik function yarating: trim, toLowerCase, va capitalize (birinchi harfni katta qiladigan). Ularni pipe() orqali birlashtirib, " hello World " matnini "Hello world" ga aylantiring.
Required Concepts:

• pipe()
• String methods (Chapter 9)
  Hint:
  capitalize function: s => s.charAt(0).toUpperCase() + s.slice(1)

🔮 Predict the Output

script.js
JavaScriptNusxalash
01function curry(func) {
02    return function curried(...args) {
03        if (args.length >= func.length) {
04            return func.apply(this, args);
05        }
06        return (...moreArgs) => curried.apply(this, args.concat(moreArgs));
07    };
08}
09 
10function sum3(a, b, c) {
11    return a + b + c;
12}
13 
14let curried = curry(sum3);
15 
16console.log(curried(10)(20)(30));
17console.log(curried(10, 20)(30));

🧠 Think first! Javobni ko'rishdan oldin kamida 30 soniya o'ylang.

<details> <summary>Answer</summary> 60 60

Why?
curry() — argumentlarning qanday guruhlarga bo'lib berilishidan (birma-bir yoki guruh-guruh) qat'i nazar, func.length (3)ga yetguncha ularni to'playveradi. Ikkala holatda ham, jami 3 ta argument (10, 20, 30) yig'ilgach, sum3(10, 20, 30) chaqiriladi va natija — 60.

</details>

🐛 Debugging Challenge

Quyidagi kodda muammo bor:

script.js
JavaScriptNusxalash
01function compose(...funcs) {
02    return function (value) {
03        return funcs.reduce((acc, func) => func(acc), value);
04    };
05}
06 
07let addOne = x => x + 1;
08let double = x => x * 2;
09 
10let result = compose(addOne, double)(5);
11 
12console.log(result); // Dasturchi 11 kutgan (5*2=10, +1=11), lekin 12 chiqadi

Your Task:

• Nima uchun natija 12 (kutilgan 11 emas) ekanini tushuntiring.
• Kodni tuzating.

<details> <summary>Solution</summary> Muammo: Bu funksiya compose deb nomlangan, lekin ichida oddiy reduce() (chapdan o'ngga) ishlatilgan — bu aslida pipe()ning xatti-harakati! compose(addOne, double) — "avval double, keyin addOne" degan an'anaviy composition ma'nosini anglatishi kerak edi (o'ngdan chapga), lekin kod uni "avval addOne, keyin double" (chapdan o'ngga: 5+1=6, 6*2=12) qilib bajarmoqda.

Yechim — reduceRight() ishlatish (haqiqiy compose uchun):

script.js
JavaScriptNusxalash
01function compose(...funcs) {
02    return function (value) {
03        return funcs.reduceRight((acc, func) => func(acc), value);
04    };
05}
06 
07let result = compose(addOne, double)(5);
08// double(5) = 10, keyin addOne(10) = 11
09console.log(result); // 11

</details>

📌 Chapter Summary

• Currying — ko'p argumentli functionni, bitta-bittadan argument qabul qiluvchi zanjirga aylantiradi.
• Currying — qisman qo'llash (partial application) orqali moslashtirilgan function'lar yaratishga imkon beradi.
• Function Composition — bir nechta kichik function'ni, natijalari ketma-ket uzatiladigan bitta katta functionga birlashtiradi.
• compose() — o'ngdan chapga, pipe() — chapdan o'ngga ishlaydi.

🎯 Key Takeaways

• Currying — Closure (Chapter 12) va Higher-Order Function (Chapter 14) tamoyillarining bevosita amaliy qo'llanilishi.
• func.length — function'ning kutilayotgan parametrlar sonini avtomatik aniqlash uchun ishlatilishi mumkin.
• Function Composition — kod takrorlanishini kamaytirib, kichik, "bir vazifali" function'lardan katta mantiq qurish imkonini beradi.
• compose va pipe — bir xil g'oyaning ikki yo'nalishdagi (o'ngdan chapga / chapdan o'ngga) amalga oshirilishi.
• Bu texnikalar — funksional dasturlash uslubining asosiy qurilish bloklari hisoblanadi.

⚡ Quick Cheat Sheet

script.js
JavaScriptNusxalash
01// Curry
02function curry(fn) {
03    return function curried(...args) {
04        return args.length >= fn.length
05            ? fn.apply(this, args)
06            : (...more) => curried.apply(this, args.concat(more));
07    };
08}
09 
10// Compose (o'ngdan chapga)
11const compose = (...fns) => x => fns.reduceRight((acc, fn) => fn(acc), x);
12 
13// Pipe (chapdan o'ngga)
14const pipe = (...fns) => x => fns.reduce((acc, fn) => fn(acc), x);

---