fp-ts für TypeScript: Der komplette Guide zur funktionalen Programmierung

1. Was ist fp-ts und warum braucht man es?

fp-ts (Functional Programming in TypeScript) ist eine leistungsstarke Open-Source-Bibliothek, die das Paradigma der funktionalen Programmierung (FP) in TypeScript bringt. Sie bietet eine Reihe von Typen, Funktionen und Kombinatoren, die von Sprachen wie Haskell, PureScript und Scala inspiriert sind. Anders als bei imperativen oder objektorientierten Ansätzen ermöglicht fp-ts das Schreiben von reinem, vorhersagbarem und leicht testbarem Code. Die Bibliothek basiert auf Konzepten wie Funktoren, Monaden, applicativen Funktoren und anderen Abstraktionen, die helfen, Seiteneffekte zu verwalten, Fehler zu behandeln und asynchrone Operationen ohne Exceptions und Zustandsmutationen durchzuführen.

Warum fp-ts verwenden? In der modernen TypeScript-Entwicklung treten häufig Probleme auf: unerwartete Exceptions (z.B. bei null oder undefined), schwieriges Testen aufgrund versteckter Abhängigkeiten und Seiteneffekte sowie unübersichtlicher asynchroner Code mit Callbacks. fp-ts löst diese Probleme durch ein strenges Typsystem und komponierbare Abstraktionen. Beispielsweise modelliert der Typ Option explizit das Fehlen eines Wertes, während Either die Fehlerbehandlung ohne try/catch ermöglicht. Das macht den Code sicherer und auf Typebene besser dokumentiert.

Die Bibliothek ist besonders nützlich in Projekten mit hoher Komplexität der Geschäftslogik, wo Zuverlässigkeit und Wartbarkeit entscheidend sind. Sie eignet sich auch hervorragend für Teams, die funktionale Prinzipien schrittweise einführen möchten, ohne das gesamte Projekt umschreiben zu müssen. fp-ts wird aktiv von der Community unterstützt und verfügt über ein reichhaltiges Ökosystem, einschließlich Integrationen mit io-ts (Datenvalidierung), monocle-ts (Linsen) und hyper-ts (Webserver).

2. Installation

fp-ts wird über npm verteilt. Führen Sie zur Installation folgenden Befehl aus:

npm install fp-ts

Es wird außerdem empfohlen, @types/node zu installieren, um die Node.js-Typen zu unterstützen, falls Sie nicht im Browser arbeiten:

npm install -D @types/node

Für die Arbeit mit fp-ts wird TypeScript Version 4.0 oder höher benötigt. Stellen Sie sicher, dass in Ihrer tsconfig.json die Option "strict": true aktiviert ist, um maximale Typsicherheit zu gewährleisten.

3. Schnellstart – Minimales Arbeitsbeispiel

Betrachten wir ein einfaches Beispiel: die sichere Division zweier Zahlen mit Behandlung der Division durch Null. Ohne fp-ts würden wir schreiben:

function divide(a: number, b: number): number | null {
  if (b === 0) return null;
  return a / b;
}

const result = divide(10, 2);
if (result !== null) {
  console.log(result); // 5
}

Mit fp-ts verwenden wir den Typ Option:

import { pipe } from 'fp-ts/function';
import { Option, some, none, fromPredicate } from 'fp-ts/Option';

const safeDivide = (a: number, b: number): Option =>
  pipe(
    b,
    fromPredicate((x) => x !== 0),
    Option.map((divisor) => a / divisor)
  );

const result = safeDivide(10, 2);
// result: Option — some(5) oder none

// Wert extrahieren
import { fold } from 'fp-ts/Option';

const message = pipe(
  result,
  fold(
    () => 'Fehler: Division durch Null',
    (value) => `Ergebnis: ${value}`
  )
);
console.log(message); // "Ergebnis: 5"

Dieses Beispiel zeigt die Kernprinzipien von fp-ts: Komposition durch pipe, explizite Modellierung fehlender Werte und Fehlerbehandlung ohne Exceptions.

4. Wichtige Methoden/Funktionen/Klassen

4.1. Option – Arbeiten mit optionalen Werten

Signatur:

// Konstruktoren
declare const some: (a: A) => Option;
declare const none: Option;

// Wichtige Methoden
declare const map: (f: (a: A) => B) => (fa: Option