Programmation fonctionnelle en TypeScript : bases et exemples

Programmation fonctionnelle en TypeScript : de la théorie à la pratique

La programmation fonctionnelle (PF) est un paradigme basé sur le calcul par l'application de fonctions et l'évitement des mutations d'état. TypeScript, en tant que sur-ensemble strictement typé de JavaScript, fournit des outils puissants pour implémenter la PF. Dans cet article, nous allons détailler les concepts clés de la programmation fonctionnelle en TypeScript avec des exemples de code pratiques.

1. Fonctions pures et immutabilité

Une fonction pure est une fonction qui :

• Retourne toujours le même résultat pour les mêmes arguments (déterminisme).
• N'a pas d'effets secondaires (ne modifie pas les variables externes, n'effectue pas d'opérations d'E/S).

// Fonction pureconst add = (a: number, b: number): number => a + b;

// Fonction impure (effet secondaire — modification d'un état externe)let counter = 0;const increment = (): number => ++counter;

L'immutabilité signifie que les données ne sont pas modifiées, mais que de nouvelles copies sont créées. En TypeScript, on peut utiliser l'opérateur spread et les méthodes sans mutation :

interface User {  name: string;  age: number;}

// Mutation (mauvais)const updateAgeMutable = (user: User, newAge: number): void => {  user.age = newAge;};

// Approche immuable (bon)const updateAgeImmutable = (user: User, newAge: number): User => ({  ...user,  age: newAge,});

L'immutabilité simplifie le débogage et les tests, car les données sont toujours prévisibles.

2. Fonctions d'ordre supérieur et fermetures

Les fonctions d'ordre supérieur sont des fonctions qui prennent d'autres fonctions comme arguments ou les retournent. Exemple — la méthode Array.map :

const numbers: number[] = [1, 2, 3, 4];const doubled: number[] = numbers.map((x) => x * 2);console.log(doubled); // [2, 4, 6, 8]

Une fermeture est une fonction qui "se souvient" des variables de la portée externe même après que la fonction externe a terminé son exécution :

const createMultiplier = (factor: number): ((x: number) => number) => {  return (x: number) => x * factor;};

const double = createMultiplier(2);const triple = createMultiplier(3);

console.log(double(5)); // 10console.log(triple(5)); // 15

Les fermetures sont largement utilisées pour créer des fonctions avec une application partielle des arguments (currying).

3. Composition de fonctions et currying

La composition de fonctions est la combinaison de plusieurs fonctions en une seule, où la sortie d'une fonction est l'entrée de la suivante. En TypeScript, on peut écrire une utilitaire pour la composition :

const compose = <T, R>(...fns: Array<(arg: T) => T>) => (arg: T): T =>   fns.reduceRight((acc, fn) => fn(acc), arg);

// Exemple : transformation d'une chaîneconst toUpperCase = (s: string): string => s.toUpperCase();const exclaim = (s: string): string => `${s}!`;const shout = compose(toUpperCase, exclaim);

console.log(shout("hello")); // "HELLO!"

Le currying est la transformation d'une fonction avec plusieurs arguments en une séquence de fonctions avec un seul argument :

// Fonction normaleconst add = (a: number, b: number): number => a + b;

// Version curryfiéeconst curriedAdd = (a: number) => (b: number): number => a + b;

const add5 = curriedAdd(5);console.log(add5(3)); // 8

Le currying simplifie la création de fonctions spécialisées et améliore la réutilisabilité du code.

4. Monades et travail avec Option/Maybe

Une monade est un patron de conception de la programmation fonctionnelle qui encapsule une valeur et fournit une interface pour sa transformation. L'une des monades les plus simples est Maybe (ou Option), qui traite de manière sécurisée n