Kurs JavaScript i TypeScript · Moduł 12: Programowanie funkcyjne

Wzorce FP: funktory i monady

6 min czytania ·
W tej lekcji4

Ustalenie strefy dinozaura to trzy kroki: znajdź dinozaura, weź jego zoneId, znajdź strefę. Każdy krok może zwrócić undefined, a jedno przeoczone sprawdzenie kończy się w środku nocnej zmiany błędem TypeError: Cannot read properties of undefined. Kod pełen ifów chroni przed tym, ale zasłania to, co naprawdę robimy.

W zaawansowanym laboratorium Parku Jurajskiego nie zawsze mamy pewność, czy próbka DNA istnieje, czy analiza się powiodła, czy dane są kompletne. Zamiast sprawdzać warunki na każdym kroku (if/else), możemy użyć eleganckich wzorców z programowania funkcyjnego - funktorów i monad. To jak inteligentne pojemniki na próbki, które same wiedzą, jak obsłużyć brakujące lub uszkodzone dane.

Funktory - pojemniki z mapowaniem

Funktor to obiekt (pojemnik), który implementuje metodę map. Pozwala stosować transformacje do wartości wewnątrz pojemnika, bez konieczności jej wyciągania. Jeden funktor już znasz: tablica, której map przekształca zawartość i zwraca nową tablicę. Najprostszy własny funktor to pudełko na jedną wartość:

// Najprostszy funktor - Box (pojemnik)
class Box {
  constructor(value) {
    this.value = value;
  }

  map(fn) {
    return new Box(fn(this.value));
  }

  toString() {
    return 'Box(' + this.value + ')';
  }
}

map nie zmienia this.value, tylko tworzy nowy Box z wynikiem funkcji - to ta sama zasada niemutowalności, którą znasz z poprzedniej lekcji. Ponieważ każde map zwraca pudełko, wywołania łączą się w łańcuch:

// Użycie - łańcuch transformacji
const result = new Box(8000)
  .map((weight) => weight / 1000)      // Box(8)
  .map((tons) => tons + ' tons')        // Box('8 tons')
  .map((label) => 'Weight: ' + label);  // Box('Weight: 8 tons')

console.log(result.value); // 'Weight: 8 tons'

Każdy krok dostaje odpakowaną wartość, a wynik wraca do pudełka. Dopiero na końcu sięgamy po result.value.

Maybe - obsługa brakujących wartości

Monada Maybe rozwiązuje problem wartości null/undefined. Zamiast wszędzie sprawdzać if (x !== null), owijamy wartość w Maybe i pozwalamy monadzie obsługiwać brakujące dane. Statyczna metoda of tworzy pojemnik, isNothing sprawdza, czy jest pusty, map działa jak w Box, ale omija pusty pojemnik, flatMap przyjmuje funkcję zwracającą kolejne Maybe, a getOrElse wyciąga wartość lub zwraca domyślną:

class Maybe {
  constructor(value) {
    this.value = value;
  }

  static of(value) {
    return new Maybe(value);
  }

  isNothing() {
    return this.value === null || this.value === undefined;
  }

  map(fn) {
    return this.isNothing() ? this : Maybe.of(fn(this.value));
  }

  flatMap(fn) {
    return this.isNothing() ? this : fn(this.value);
  }

  getOrElse(defaultValue) {
    return this.isNothing() ? defaultValue : this.value;
  }
}

Całe bezpieczeństwo siedzi w jednym warunku: pusty Maybe na każde map odpowiada samym sobą, więc funkcja nigdy nie dostanie undefined. Porównaj teraz wyszukiwanie strefy bez Maybe i z nim:

// Bez Maybe - pełno ifów
function getDinoZoneOld(park, dinoId) {
  const dino = park.dinosaurs.find((d) => d.id === dinoId);
  if (!dino) return 'Unknown';
  const zone = park.zones.find((z) => z.id === dino.zoneId);
  if (!zone) return 'Unknown';
  return zone.name;
}

// Z Maybe - elegancki łańcuch
function getDinoZone(park, dinoId) {
  return Maybe.of(park.dinosaurs.find((d) => d.id === dinoId))
    .map((dino) => dino.zoneId)
    .flatMap((zoneId) => Maybe.of(park.zones.find((z) => z.id === zoneId)))
    .map((zone) => zone.name)
    .getOrElse('Unknown');
}

Ify zniknęły, a przypadek "nie znaleziono" obsługuje jedno getOrElse na końcu. Przy strefie używamy flatMap, bo funkcja z tego kroku sama zwraca Maybe - zwykłe map dałoby Maybe w Maybe. Porządek jest zawsze ten sam: owiń przez Maybe.of, przekształcaj przez map, kroki zwracające Maybe łącz przez flatMap, a wynik wyciągnij przez getOrElse. Najkrótszy łańcuch to Maybe.of(data).map((d) => d.name).getOrElse('Unknown').

Tę samą parę znasz z tablic. flatMap najpierw mapuje, a potem spłaszcza wynik o jeden poziom:

const zoneIds = ['A', 'B'];
const dinosByZone = { A: ['Rex', 'Blue'], B: ['Brachio'] };

zoneIds.map((id) => dinosByZone[id]);     // [['Rex', 'Blue'], ['Brachio']]
zoneIds.flatMap((id) => dinosByZone[id]); // ['Rex', 'Blue', 'Brachio']

map zwraca tablicę tablic, a flatMap jedną płaską listę. Maybe.flatMap robi to samo z pudełkami. Do prostego odczytu pól wystarczy wbudowane dino?.zone ?? 'Unknown', a Maybe opłaca się, gdy kroki to całe wyszukiwania.

Either - obsługa błędów

Maybe mówi tylko, że wartości brak, ale nie mówi dlaczego. Either reprezentuje wartość, która może być sukcesem (Right) lub porażką (Left). To funkcyjna alternatywa dla try/catch:

class Left {
  constructor(value) { this.value = value; }
  map(fn) { return this; }           // Ignoruje transformacje
  flatMap(fn) { return this; }
  getOrElse(defaultValue) { return defaultValue; }
  isLeft() { return true; }
  isRight() { return false; }
}

class Right {
  constructor(value) { this.value = value; }
  map(fn) { return new Right(fn(this.value)); }
  flatMap(fn) { return fn(this.value); }
  getOrElse(defaultValue) { return this.value; }
  isLeft() { return false; }
  isRight() { return true; }
}

Obie klasy mają to samo API, ale Right.map stosuje funkcję, a Left.map ją pomija i niesie błąd dalej. Po pierwszej porażce reszta łańcucha się nie wykonuje. Zobaczmy to przy walidacji próbki:

// Użycie w walidacji próby DNA
function validateSample(sample) {
  if (!sample.id) return new Left('Missing sample ID');
  if (sample.purity < 0.5) return new Left('Purity too low: ' + sample.purity);
  if (!sample.species) return new Left('Unknown species');
  return new Right(sample);
}

function processSample(sample) {
  return validateSample(sample)
    .map((s) => ({ ...s, processed: true }))
    .map((s) => ({ ...s, label: s.species + '-' + s.id }));
}

// Sukces
const good = processSample({ id: 'S001', purity: 0.95, species: 'T-Rex' });
good.getOrElse('Error'); // { id: 'S001', purity: 0.95, species: 'T-Rex', processed: true, label: 'T-Rex-S001' }

// Porażka
const bad = processSample({ id: 'S002', purity: 0.3, species: 'Raptor' });
bad.getOrElse('Error'); // 'Error' (błąd: 'Purity too low: 0.3')

Próbka S001 przechodzi obie transformacje. Dla S002 oba map są pomijane, ale komunikat nie ginie: leży w bad.value, a bad.isLeft() zwraca true. Either nie łapie jednak wyjątków sam z siebie, więc try/catch zostaw na granicy z kodem, który rzuca, jak JSON.parse.

Jak to wszystko się łączy

W żargonie FP monada to funktor, który ma też flatMap (w bibliotekach często chain) i sposób na włożenie wartości do pojemnika, jak of. Filary tego modułu budują się od podstaw: czyste funkcje, niemutowalność, funkcje wyższego rzędu, kompozycja z curryingiem, a na szczycie funktory i monady. W tej samej kolejności refaktoryzujesz kod imperatywny: znajdujesz efekty uboczne, wydzielasz czyste funkcje, pętle zamieniasz na map, filter i reduce, łączysz kroki przez pipe, a ryzykowne miejsca owijasz w Maybe lub Either. Pipeline danych ma podobne warstwy: parsowanie, walidacja z Maybe lub Either, transformacja przez map, agregacja przez reduce i raport - zbudujesz go w projekcie końcowym. Nie owijaj jednak wszystkiego w pojemniki: opłacają się na granicy z danymi z zewnątrz.

Funktor i monada to po prostu pojemnik na próbkę, który sam wie, co zrobić z brakującą lub uszkodzoną zawartością, dzięki czemu Maybe i Either prowadzą łańcuch transformacji do końca zamiast zasypywać Twój kod dziesiątkami sprawdzeń i bloków try/catch.

Kod do tej lekcji: index.js
// Wzorce FP: funktory i monady
console.log("=== Park Jurajski - Inteligentne Pojemniki DNA ===\n");

// --- PRZYKLAD 1: Funktor Box ---
console.log("--- Funktor Box ---");

class Box {
  constructor(value) { this.value = value; }
  map(fn) { return new Box(fn(this.value)); }
  toString() { return "Box(" + JSON.stringify(this.value) + ")"; }
}

const result = new Box(8000)
  .map((w) => w / 1000)
  .map((t) => t + " tons")
  .map((l) => "Weight: " + l);

console.log(result.toString()); // Box("Weight: 8 tons")

// --- PRZYKLAD 2: Maybe ---
console.log("\n--- Monada Maybe ---");

class Maybe {
  constructor(value) { this.value = value; }
  static of(v) { return new Maybe(v); }
  isNothing() { return this.value === null || this.value === undefined; }
  map(fn) { return this.isNothing() ? this : Maybe.of(fn(this.value)); }
  flatMap(fn) { return this.isNothing() ? this : fn(this.value); }
  getOrElse(def) { return this.isNothing() ? def : this.value; }
  toString() { return this.isNothing() ? "Maybe(Nothing)" : "Maybe(" + JSON.stringify(this.value) + ")"; }
}

const park = {
  dinosaurs: [
    { id: "D01", name: "Rex", zoneId: "Z01" },
    { id: "D02", name: "Blue", zoneId: "Z02" },
  ],
  zones: [
    { id: "Z01", name: "Zone A" },
    { id: "Z02", name: "Zone B" },
  ],
};

function getDinoZone(parkData, dinoId) {
  return Maybe.of(parkData.dinosaurs.find((d) => d.id === dinoId))
    .map((dino) => dino.zoneId)
    .flatMap((zoneId) => Maybe.of(parkData.zones.find((z) => z.id === zoneId)))
    .map((zone) => zone.name)
    .getOrElse("Unknown");
}

console.log("Rex zone:", getDinoZone(park, "D01"));    // Zone A
console.log("Blue zone:", getDinoZone(park, "D02"));   // Zone B
console.log("Unknown:", getDinoZone(park, "D99"));     // Unknown

// --- PRZYKLAD 3: Either ---
console.log("\n--- Monada Either ---");

class Left {
  constructor(value) { this.value = value; }
  map(fn) { return this; }
  flatMap(fn) { return this; }
  getOrElse(def) { return def; }
  isLeft() { return true; }
  isRight() { return false; }
  toString() { return "Left(" + this.value + ")"; }
}

class Right {
  constructor(value) { this.value = value; }
  map(fn) { return new Right(fn(this.value)); }
  flatMap(fn) { return fn(this.value); }
  getOrElse(def) { return this.value; }
  isLeft() { return false; }
  isRight() { return true; }
  toString() { return "Right(" + JSON.stringify(this.value) + ")"; }
}

function validateSample(sample) {
  if (!sample.id) return new Left("Missing sample ID");
  if (sample.purity < 0.5) return new Left("Purity too low: " + sample.purity);
  if (!sample.species) return new Left("Unknown species");
  return new Right(sample);
}

function processSample(sample) {
  return validateSample(sample)
    .map((s) => ({ ...s, processed: true }))
    .map((s) => ({ ...s, label: s.species + "-" + s.id }));
}

const good = processSample({ id: "S01", purity: 0.95, species: "T-Rex" });
console.log("Success:", good.toString());
console.log("Value:", JSON.stringify(good.getOrElse("ERROR")));

const bad1 = processSample({ id: "", purity: 0.95, species: "T-Rex" });
console.log("\nFail 1:", bad1.toString());

const bad2 = processSample({ id: "S02", purity: 0.3, species: "Raptor" });
console.log("Fail 2:", bad2.toString());

// --- PRZYKLAD 4: Lancuch Either ---
console.log("\n--- Lancuch Either ---");

function parseInput(raw) {
  try { return new Right(JSON.parse(raw)); }
  catch (e) { return new Left("Parse error: " + e.message); }
}

const pipeline = (raw) =>
  parseInput(raw)
    .flatMap((data) => data.name ? new Right(data) : new Left("Missing name"))
    .map((data) => ({ ...data, status: "validated" }));

console.log(pipeline('{"name":"Rex"}').toString());
console.log(pipeline('{"age":5}').toString());
console.log(pipeline('invalid json').toString());

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. Co musi implementować obiekt, aby był funktorem?

  2. 2. Co zwraca Array.flatMap() w porównaniu do Array.map()?

To 2 z 3 pytań do tej lekcji. Pozostałe rozwiążesz w grze.

Zadania praktyczne w grze

  • Układanie w pionie

    Ułóż kroki bezpiecznego pobierania danych z użyciem Maybe:

  • Układanie w poziomie

    Ułóż elementy wywołania flatMap na Maybe:

  • Układanie w poziomie

    Ułóż elementy łańcucha Maybe do bezpiecznego wyciągania danych:

  • Klikanie w kolejności

    Ułóż elementy walidacji z Either:

  • Układanie w pionie

    Ułóż filary programowania funkcyjnego od najbardziej podstawowego:

  • Edytor kodu

    Zaimplementuj bezpieczne wyszukiwanie i walidację danych z użyciem Maybe i Either.

  • Układanie w pionie

    Ułóż elementy implementacji memoize z domknięciem:

  • Klikanie w kolejności

    Ułóż elementy grupowania tablicy z reduce:

  • Układanie w pionie

    Ułóż etapy budowania funkcyjnego pipeline przetwarzania danych:

  • Układanie w poziomie

    Ułóż elementy implementacji partial application:

  • Klikanie w kolejności

    Ułóż elementy pipeline filter-map-reduce:

  • Układanie w pionie

    Ułóż etapy refaktoringu z kodu imperatywnego na funkcyjny:

  • Układanie w pionie

    Ułóż warstwy funkcyjnego pipeline przetwarzania danych od wejścia do wyjścia:

  1. PytanieFunktor
  2. Ułóż w kolejnościPrzetwarzanie z Maybe
  3. Ułóż w kolejnościSkładnia flatMap na Maybe
  4. Ułóż w kolejnościSkładnia łańcucha Maybe
  5. Kliknij w kolejnościWalidacja z Either
  6. PytanieArray.flatMap() vs Array.map()
  7. Ułóż w kolejnościZasady programowania funkcyjnego
  8. Zadanie z kodemMaybe i Either w praktyce
  9. Ułóż w kolejnościSkładnia memoize z closure
  10. Kliknij w kolejnościPipeline z reduce
  11. Ułóż w kolejnościEtapy budowania pipeline FP
  12. PytanieObject.freeze() vs const
  13. Ułóż w kolejnościSkładnia partial application
  14. Kliknij w kolejnościŁańcuch filter-map-reduce
  15. Ułóż w kolejnościEtapy refaktoringu na styl funkcyjny
  16. Ułóż w kolejnościWarstwy funkcyjnego pipeline danych

Przydatne artykuły