Aller au contenu principal

Zygos vs Neverthrow : quel type Result pour TypeScript ?

Neverthrow a popularisé le pattern Result en TypeScript : une façon de rendre les erreurs explicites dans les signatures de fonctions au lieu de s'appuyer sur try/catch. C'est bien conçu et largement adopté.

Zygos est une micro-implémentation du même pattern : 100% compatible API avec Neverthrow, mais 2.6x plus petit. Il fournit aussi les monades Option, Either, Task et TaskEither pour les projets qui ont besoin de plus que Result. Cette page compare les deux bibliothèques sur les dimensions qui comptent en production.

En un coup d'œil​

AspectZygosNeverthrow
API Result100% compatible—
API ResultAsync100% compatible—
Taille de bundle~774 B (2.6x plus petit)~1.96 kB
Sécurité des typesZéro type anyUtilise any à certains endroits
Monades supplémentairesOption, Either, Task, TaskEitherResult uniquement
Ponts fp-tsOui (fromOption, fromEither, toEither)Non
DépendancesZéroZéro
Effort de migrationChangement d'import uniquement—

Taille de bundle​

Zygos Result est 2.6x plus petit (~774 B vs ~1.96 kB) par rapport à Neverthrow (gzippé). La différence vient de l'approche d'implémentation : Zygos utilise de simples littéraux d'objets ({ _tag: "Ok", value }) tandis que Neverthrow utilise l'instanciation de classes avec plus de surcharge.

Pour des comparaisons détaillées par module avec des données auto-générées, consultez la comparaison de taille de bundle Zygos.

// Zygos : Result + ResultAsync
import { ok, err, Result } from "pithos/zygos/result/result";
import { ResultAsync } from "pithos/zygos/result/result-async";

// Neverthrow : importer n'importe quelle fonction embarque la bibliothèque entière
import { ok, err, Result, ResultAsync } from "neverthrow";

Performance​

Zygos est 2-4x plus rapide sur la création d'objets et les opérations chaînées. Les vérifications simples de propriétés (isOk, isErr, unwrapOr) performent de manière identique dans les deux bibliothèques.

Pour des résultats de benchmarks détaillés avec des données auto-générées, consultez les benchmarks de performance Zygos.

Résultats clés :

  • Création d'objets (ok(), err()) : Zygos est 2-3x plus rapide (littéraux d'objets vs instanciation de classes)
  • Opérations chaînées (andThen) : Zygos est 2-4x plus rapide
  • Vérifications simples (isOk, unwrapOr) : équivalent, les deux sont des accès de propriétés

100% de compatibilité API​

Zygos est un remplacement direct. Chaque méthode Result et ResultAsync fonctionne de manière identique :

// Changez juste l'import, zéro changement de code
import { ok, err, Result, safeTry } from "pithos/zygos/result/result";
import { ResultAsync, okAsync, errAsync } from "pithos/zygos/result/result-async";

// Tous les patterns Neverthrow fonctionnent tels quels
const result = ok(5)
  .map(x => x * 2)
  .mapErr(e => `Error: ${e}`)
  .andThen(x => x > 0 ? ok(x) : err("negative"));

const asyncResult = ResultAsync.fromPromise(
  fetch("/api/data"),
  () => "Network error"
);

const combined = Result.combine([ok(1), ok(2), ok(3)]); // Ok([1, 2, 3])

Pour la matrice de compatibilité complète, consultez la page d'interopérabilité Zygos ↔ Neverthrow.

Ce que Zygos ajoute au-delà de Neverthrow​

Ponts fp-ts​

Convertissez entre Result et les types fp-ts sans mapping manuel :

import { fromOption, fromEither, toEither } from "pithos/zygos/result/result";

// Option → Result
const fromSome = fromOption(() => "No value")(someOption); // Ok(42)

// Either → Result
const fromRight = fromEither(rightEither); // Ok(42)

// Result → Either
const either = toEither(ok(42)); // { _tag: "Right", right: 42 }

Monades supplémentaires​

Zygos fournit Option, Either, Task et TaskEither, des implémentations légères compatibles avec fp-ts :

// Option : absence explicite (pas de null/undefined)
import { some, none, fromNullable } from "pithos/zygos/option";

// Either, Task, TaskEither : compatible fp-ts
import * as E from "pithos/zygos/either";
import * as T from "pithos/zygos/task";
import * as TE from "pithos/zygos/task-either";

Zéro type any​

Neverthrow utilise any dans certains types internes. Zygos utilise unknown partout, offrant une sécurité des types plus stricte et attrapant plus d'erreurs au compile-time.

safeAsyncTry​

Gestion d'erreurs async simplifiée sans générateurs :

import { safeAsyncTry } from "pithos/zygos/result/result";

const result = await safeAsyncTry(() => fetch("/api/users/123").then(r => r.json()));

Guide de migration​

Prêt à migrer ? Le guide de migration complet étape par étape se trouve dans la documentation du module Zygos: installer, changer les imports et commencer à utiliser les fonctionnalités supplémentaires. Aller au guide de migration →

Pas sûr de quelle bibliothèque correspond à votre cas d'usage ? Voir l'aperçu des comparaisons.

Pour aller plus loin