Kurs JavaScript i TypeScript · Moduł 12: Programowanie funkcyjne

Currying i częściowa aplikacja

5 min czytania ·
W tej lekcji5

Wyobraź sobie system karmienia dinozaurów w parku. Każdy gatunek ma swoje wymagania - rodzaj pożywienia, porcję i porę karmienia. Zamiast za każdym razem podawać wszystkie parametry, możemy przygotować funkcje "wstępnie skonfigurowane" dla danego gatunku. To właśnie robi currying - przekształca funkcję wieloargumentową w sekwencję funkcji jednoargumentowych.

Jest też drugi, bardziej techniczny problem. pipe z poprzedniej lekcji przekazuje każdemu etapowi dokładnie jedną wartość, więc funkcja wymagająca gatunku, pokarmu i porcji po prostu do niego nie pasuje. Potrzebujemy sposobu, żeby część argumentów ustawić wcześniej, a na końcu zostawić funkcję jednoargumentową.

Czym jest currying?

Currying to technika przekształcania funkcji przyjmującej wiele argumentów w sekwencję funkcji, z których każda przyjmuje dokładnie jeden argument.

Zacznijmy od zwykłej funkcji z trzema parametrami i jej wersji curried zapisanej klasycznie, przez zagnieżdżone function:

// Zwykła funkcja z 3 argumentami
function feedDinosaur(species, food, portion) {
  return species + ' dostaje ' + portion + 'kg ' + food;
}
feedDinosaur('T-Rex', 'meat', 50);

// Wersja curried - sekwencja funkcji jednoargumentowych
function feedDinosaurCurried(species) {
  return function(food) {
    return function(portion) {
      return species + ' dostaje ' + portion + 'kg ' + food;
    };
  };
}
feedDinosaurCurried('T-Rex')('meat')(50);

Oba wywołania zwracają 'T-Rex dostaje 50kg meat'. Wywołanie feedDinosaurCurried('T-Rex') nikogo jeszcze nie karmi, tylko zwraca funkcję czekającą na pokarm, a dopiero trzecia para nawiasów uruchamia właściwą logikę. Wewnętrzne funkcje pamiętają species i food dzięki domknięciom, którym przyjrzymy się w następnej lekcji.

Funkcje strzałkowe pozwalają zapisać to samo znacznie krócej, bo każda strzałka to kolejny etap:

// To samo ze strzałkami (bardziej zwięźle)
const feedCurried = (species) => (food) => (portion) =>
  species + ' dostaje ' + portion + 'kg ' + food;

Czytaj to od lewej: funkcja od gatunku zwraca funkcję od pokarmu, a ta zwraca funkcję od porcji. Zmienił się tylko zapis, zachowanie jest identyczne jak w wersji z function.

Praktyczne zastosowanie curryingu

Prawdziwa siła curryingu tkwi w tworzeniu wyspecjalizowanych funkcji. Tym razem ostatni etap zwraca obiekt karmienia ze znacznikiem czasu:

const feedCurried = (species) => (food) => (portion) =>
  ({ species, food, portion, timestamp: Date.now() });

// Specjalizowane funkcje dla gatunków
const feedRex = feedCurried('T-Rex');
const feedRexMeat = feedRex('meat');

// Użycie wyspecjalizowanych funkcji
feedRexMeat(50);  // { species: 'T-Rex', food: 'meat', portion: 50, ... }
feedRexMeat(30);  // { species: 'T-Rex', food: 'meat', portion: 30, ... }

// Można też dla innego gatunku
const feedBrachio = feedCurried('Brachiosaurus');
const feedBrachioPlants = feedBrachio('plants');
feedBrachioPlants(200); // { species: 'Brachiosaurus', food: 'plants', portion: 200, ... }

feedRex i feedRexMeat to zwykłe funkcje, które możesz przechowywać, przekazywać i wywoływać wiele razy, a feedCurried pozostaje ogólna i bez przeszkód obsłuży Brachiozaura. Zapis { species, food, portion } to skrót od { species: species, ... }. Uwaga techniczna: Date.now() sprawia, że ostatni etap nie jest czysty, bo dwa wywołania z tą samą porcją dadzą różne znaczniki czasu. Wersja bez czasu, const feed = (species) => (food) => (portion) => ({ species, food, portion }), jest już czysta.

Uniwersalna funkcja curry

Możemy napisać uniwersalną funkcję curry, która automatycznie przekształca dowolną funkcję. Kluczem jest właściwość fn.length, czyli liczba parametrów zadeklarowanych przez funkcję (bez parametru resztowego i bez parametrów od pierwszego z wartością domyślną):

function curry(fn) {
  return function curried(...args) {
    if (args.length >= fn.length) {
      return fn(...args);
    }
    return (...moreArgs) => curried(...args, ...moreArgs);
  };
}

curried zbiera argumenty. Gdy jest ich już co najmniej tyle, ile wynosi fn.length, wywołuje oryginał, a w przeciwnym razie zwraca funkcję, która dołoży kolejne. Sprawdźmy to na funkcji budującej wybieg:

// Użycie
function createEnclosure(zone, type, capacity, voltage) {
  return { zone, type, capacity, voltage };
}

const curriedCreate = curry(createEnclosure);

// Można wywołać na różne sposoby:
curriedCreate('A')('carnivore')(5)(10000);
curriedCreate('A', 'carnivore')(5, 10000);
curriedCreate('A', 'carnivore', 5)(10000);
curriedCreate('A', 'carnivore', 5, 10000);
// Wszystkie wywołania dają ten sam wynik

Każde wywołanie zwraca { zone: 'A', type: 'carnivore', capacity: 5, voltage: 10000 }. Ściśle biorąc, wersja przyjmująca kilka argumentów naraz łączy currying z częściową aplikacją. Tak działają też funkcje curry z bibliotek Ramda i lodash. Pułapka: funkcja zadeklarowana jako (...args) => ... ma length równe 0, więc curry wywoła ją od razu.

Częściowa aplikacja (Partial Application)

Częściowa aplikacja to pokrewna technika - "zamraża" część argumentów funkcji, tworząc nową funkcję z mniejszą liczbą parametrów.

partial przyjmuje funkcję i dowolną liczbę argumentów startowych (presetArgs), a zwraca funkcję czekającą na resztę (laterArgs). Operator spread skleja obie listy w jedno wywołanie:

function partial(fn, ...presetArgs) {
  return (...laterArgs) => fn(...presetArgs, ...laterArgs);
}

Zastosujmy ją do funkcji dziennika incydentów, z której korzysta cała ochrona parku, i zbudujmy z niej kilka wyspecjalizowanych loggerów:

// Funkcja logowania incydentów
function logIncident(severity, zone, message) {
  return '[' + severity + '] Zone ' + zone + ': ' + message;
}

// Wyspecjalizowane loggery
const logCritical = partial(logIncident, 'CRITICAL');
const logWarning = partial(logIncident, 'WARNING');
const logCriticalZoneA = partial(logIncident, 'CRITICAL', 'A');

logCritical('B', 'Fence breach detected');
// '[CRITICAL] Zone B: Fence breach detected'

logCriticalZoneA('T-Rex escaped!');
// '[CRITICAL] Zone A: T-Rex escaped!'

W logCritical zamrożony jest jeden argument, a w logCriticalZoneA od razu dwa. Pierwotna logIncident się nie zmieniła i nadal przyjmuje trzy argumenty. Ten sam efekt da wbudowane bind: logIncident.bind(null, 'CRITICAL').

Currying vs częściowa aplikacja

Choć obie techniki tworzą wyspecjalizowane funkcje, różnią się sposobem działania:

  • Currying: zawsze tworzy łańcuch funkcji jednoargumentowych
  • Częściowa aplikacja: "zamraża" dowolną liczbę argumentów naraz

Specjalizacja przez currying ma zawsze te same etapy: definiujesz ogólną funkcję curried, podajesz pierwszy argument i dostajesz funkcję częściowo zastosowaną, kolejne argumenty dalej ją zawężają, a ostatni zwraca wynik. Moja rada: funkcje do pipeline'ów pisz w kolejności "konfiguracja najpierw, dane na końcu", na przykład filterBy(key)(value)(arr). Po podaniu konfiguracji zostaje funkcja jednoargumentowa gotowa do pipe, a do jednorazowego zamrożenia kilku argumentów istniejącej funkcji wystarczy partial. W projekcie końcowym właśnie tak zbudujesz narzędzia do filtrowania odczytów.

Pamiętaj: currying to stacja karmienia konfigurowana krok po kroku - gatunek, pokarm, porcja - a każde ustawienie daje Ci nową, gotową do pracy maszynę.

Kod do tej lekcji: index.js
// Currying i czesciowa aplikacja
console.log("=== Park Jurajski - Etapowe Przetwarzanie Gatunkow ===\n");

// --- PRZYKLAD 1: Podstawowy currying ---
console.log("--- Currying: System karmienia ---");

const feedDinosaur = (species) => (food) => (portion) =>
  `${species} dostaje ${portion}kg ${food}`;

// Specjalizowane funkcje
const feedRex = feedDinosaur("T-Rex");
const feedRexMeat = feedRex("meat");

console.log(feedRexMeat(50));  // T-Rex dostaje 50kg meat
console.log(feedRexMeat(30));  // T-Rex dostaje 30kg meat

const feedBrachio = feedDinosaur("Brachiosaurus");
console.log(feedBrachio("plants")(200)); // Brachiosaurus dostaje 200kg plants

// --- PRZYKLAD 2: Uniwersalna funkcja curry ---
console.log("\n--- Uniwersalny curry ---");

function curry(fn) {
  return function curried(...args) {
    if (args.length >= fn.length) {
      return fn(...args);
    }
    return (...moreArgs) => curried(...args, ...moreArgs);
  };
}

function createEnclosure(zone, type, capacity, voltage) {
  return { zone, type, capacity, voltage };
}

const curriedCreate = curry(createEnclosure);

// Rozne sposoby wywolania
const r1 = curriedCreate("A")("carnivore")(5)(10000);
const r2 = curriedCreate("A", "carnivore")(5, 10000);
const r3 = curriedCreate("A", "carnivore", 5, 10000);

console.log("Wywolanie 1:", JSON.stringify(r1));
console.log("Wywolanie 2:", JSON.stringify(r2));
console.log("Identyczne?", JSON.stringify(r1) === JSON.stringify(r2));

// Specjalizowane fabryki
const createCarnivoreZone = curriedCreate("X")("carnivore");
console.log("Zone X-5:", JSON.stringify(createCarnivoreZone(5)(15000)));
console.log("Zone X-10:", JSON.stringify(createCarnivoreZone(10)(20000)));

// --- PRZYKLAD 3: Czesciowa aplikacja ---
console.log("\n--- Czesciowa aplikacja ---");

function partial(fn, ...presetArgs) {
  return (...laterArgs) => fn(...presetArgs, ...laterArgs);
}

function logIncident(severity, zone, message) {
  return `[${severity}] Zone ${zone}: ${message}`;
}

const logCritical = partial(logIncident, "CRITICAL");
const logWarning = partial(logIncident, "WARNING");
const logCriticalA = partial(logIncident, "CRITICAL", "A");

console.log(logCritical("B", "Fence breach"));
console.log(logWarning("A", "Sensor malfunction"));
console.log(logCriticalA("T-Rex escaped!"));

// --- PRZYKLAD 4: Currying z map/filter ---
console.log("\n--- Currying w praktyce ---");

const filterByField = curry((field, value, arr) =>
  arr.filter((item) => item[field] === value)
);

const dinosaurs = [
  { name: "Rex", diet: "carnivore", zone: "A" },
  { name: "Blue", diet: "carnivore", zone: "A" },
  { name: "Brachio", diet: "herbivore", zone: "B" },
  { name: "Stego", diet: "herbivore", zone: "B" },
];

const filterByDiet = filterByField("diet");
const getCarnivores = filterByDiet("carnivore");
const getHerbivores = filterByDiet("herbivore");

console.log("Drapiezniki:", getCarnivores(dinosaurs).map((d) => d.name));
console.log("Roslinozerce:", getHerbivores(dinosaurs).map((d) => d.name));

Hasła z dokumentacji w tej lekcji

Widzisz błąd w tej lekcji?

Sprawdź się

Odpowiedz na pytania z tej lekcji. Wybierz odpowiedź, a od razu zobaczysz, czy jest poprawna.

  1. 1. Czym jest currying w programowaniu funkcyjnym?

  2. 2. Czym różni się częściowa aplikacja (partial application) od curryingu?

Zadania praktyczne w grze

  • Edytor kodu

    Użyj uniwersalnej funkcji curry do stworzenia wyspecjalizowanych filtrów i loggerów.

  • Układanie w pionie

    Ułóż etapy tworzenia wyspecjalizowanej funkcji przez currying:

  • Klikanie w kolejności

    Ułóż elementy curried funkcji strzałkowej:

  • Edytor kodu

    Użyj partial() do stworzenia wyspecjalizowanych filtrów i połącz je w pipeline z pipe().

  1. PytanieCzym jest currying?
  2. PytanieCzęściowa aplikacja vs currying
  3. Zadanie z kodemCurrying w praktyce
  4. Ułóż w kolejnościEtapy curryingu
  5. Kliknij w kolejnościSkładnia curried arrow function
  6. Zadanie z kodemPartial application i pipe

Przydatne artykuły