Bibliothèque neverthrow pour TypeScript : le type Result pour la gestion des erreurs

1. Qu'est-ce que c'est et pourquoi l'utiliser ?

Dans le développement TypeScript moderne, la gestion des erreurs se transforme souvent en chaos avec des blocs try/catch dispersés dans tout le code. La bibliothèque neverthrow propose une solution élégante à ce problème, inspirée des langages de programmation fonctionnelle comme Rust et Haskell. Elle fournit le type Result<T, E>, qui représente explicitement un résultat réussi (Ok) ou une erreur (Err), faisant de la gestion des erreurs une partie intégrante du système de types plutôt qu'un effet secondaire.

L'objectif principal de neverthrow est de remplacer les exceptions implicites par des types explicites. Au lieu d'écrire une fonction qui peut lever une exception à tout moment, vous retournez un Result que le compilateur TypeScript vous obligera à traiter. Cela rend le code plus prévisible, plus sûr et auto-documenté. Vous n'avez plus à deviner quelles fonctions peuvent générer une erreur : le type de retour vous le dit directement.

Cette bibliothèque est particulièrement utile dans les projets où la fiabilité est cruciale : services backend, applications financières, systèmes de traitement de données. Elle s'intègre également parfaitement avec d'autres concepts fonctionnels comme les types Option (Maybe) et peut être combinée avec des bibliothèques telles que fp-ts. neverthrow n'est pas qu'un simple utilitaire, c'est une philosophie d'écriture de code où les erreurs sont des données, et non des situations exceptionnelles.

2. Installation

Installation de neverthrow dans un projet TypeScript/NPM :

npm install neverthrow

Pour les projets utilisant yarn :

yarn add neverthrow

Pour pnpm :

pnpm add neverthrow

La bibliothèque est écrite en TypeScript et inclut des types complets, donc aucune installation supplémentaire de @types n'est nécessaire. Après l'installation, vous pouvez importer les types et fonctions principaux :

import { ok, err, Result } from 'neverthrow';

3. Démarrage rapide — exemple minimal fonctionnel

Créons une fonction simple qui divise deux nombres, mais retourne un Result au lieu de lever une exception en cas de division par zéro :

import { ok, err, Result } from 'neverthrow';

// Définition du type d'erreur
type DivisionError = { message: string; code: number };

// Fonction retournant un Result
function safeDivide(a: number, b: number): Result<number, DivisionError> {
  if (b === 0) {
    return err({ message: 'Division par zéro', code: 1001 });
  }
  return ok(a / b);
}

// Utilisation
const result = safeDivide(10, 2);

// Traitement du résultat
if (result.isOk()) {
  console.log('Résultat :', result.value); // Résultat : 5
} else {
  console.error('Erreur :', result.error.message); // Ne s'exécutera jamais
}

const errorResult = safeDivide(10, 0);

if (errorResult.isErr()) {
  console.error('Erreur :', errorResult.error.message); // Erreur : Division par zéro
}

Cet exemple illustre l'idée principale : la fonction retourne toujours un Result, et le code appelant doit vérifier si le résultat est réussi avant d'utiliser la valeur. Le compilateur TypeScript ne vous permettra pas d'accéder à result.value sans vérification préalable.

4. Méthodes / fonctions / classes principales

4.1. ok(value) — Création d'un résultat réussi

Signature :

function ok<T, E = never>(value: T): Ok<T, E>

Fonctionnement : Crée une instance Ok représentant un résultat réussi avec la valeur fournie.

Exemple :

import { ok } from 'neverthrow';

const success = ok(42);
console.log(success.isOk()); // true
console.log(success.value); // 42

4.2. err(e