Aller au contenu principal

Taille de bundle Zygos

Des chiffres réels. Pas de marketing. Données auto-générées le Feb 20, 2026.

TL;DR​

ComparaisonZygosConcurrentÉconomie
vs Neverthrow774 B1.96 kB2.6x plus petit
vs fp-ts
Option		226 B2.91 kB13.2x plus petit

Pattern Result (vs Neverthrow)​

Tailles individuelles des modules, minifiées + gzippées. Zygos est la référence.

ModuleZygosNeverthrow
Result
Result monad (ok, err, safeTry)
732 B
référence		1.94 kB
+171%
ResultAsync
ResultAsync monad (okAsync, errAsync, fromPromise)
709 B
référence		1.96 kB
+183%
Result + ResultAsync
Result + ResultAsync combined
774 B
référence		1.96 kB
+159%
Safe
Safe wrapper for try/catch
712 B
référence		1.94 kB
+179%
Données générées le Feb 20, 2026 · Mesuré avec esbuild + gzip

Zygos est 100% compatible API avec Neverthrow, rendant la migration transparente :

// Changez ceci :
import { ok, err, Result, ResultAsync } from "neverthrow";

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

// Votre code fonctionne sans modification

Monades FP (vs fp-ts)​

ModuleZygosfp-ts
Option
Option monad (some, none, map, flatMap, fold)
226 B
référence		2.91 kB
+1219%
Either
Either monad (left, right, map, flatMap, fold)
230 B
référence		3.46 kB
+1442%
Task
Task monad (of, map, flatMap)
116 B
référence		1.86 kB
+1541%
TaskEither
TaskEither monad (left, right, tryCatch, map, flatMap, fold)
268 B
référence		5.59 kB
+2036%
Données générées le Feb 20, 2026 · Mesuré avec esbuild + gzip

Différence de philosophie​

Alors que fp-ts repose sur pipe et des fonctions au niveau module, Zygos utilise une API fluide chaînable qui semble plus naturelle en TypeScript :

// Style fp-ts
import { pipe } from "fp-ts/function";
import * as E from "fp-ts/Either";

pipe(
  E.right(5),
  E.map(x => x * 2),
  E.fold(
    e => `Error: ${e}`,
    a => `Result: ${a}`
  )
);

// Style Zygos
import { ok } from "pithos/zygos/result/result";

ok(5)
  .map(x => x * 2)
  .match(
    a => `Result: ${a}`,
    e => `Error: ${e}`
  );

Comparaison combinée​

Bundles complets des bibliothèques en important tous les modules.

ModuleZygosNeverthrowfp-ts
Tous les modules Result
All Result modules (Result + ResultAsync + Safe)
822 B
référence		2.00 kB
+149%		N/D
Toutes les monades FP
All FP monads (Option + Either + Task + TaskEither)
489 B
référence		N/D9.33 kB
+1854%
Bibliothèque complète
All Zygos modules combined
1.18 kB
référence		2.00 kB
+69%		9.33 kB
+689%
Données générées le Feb 20, 2026 · Mesuré avec esbuild + gzip

Pourquoi cette différence ?​

fp-ts fournit une boîte à outils complète de programmation fonctionnelle avec les abstractions Functor, Applicative, Monad. Si vous n'avez besoin que de Result/Either pour la gestion d'erreurs, vous embarquez du code inutilisé.

Neverthrow est focalisé sur le pattern Result mais a quand même une surcharge due à son implémentation basée sur des classes. Importer n'importe quelle fonction embarque la bibliothèque entière.

Zygos est conçu de zéro pour le tree-shaking. Chaque fonction est autonome, donc vous n'embarquez que ce que vous utilisez.

Reproduire ces résultats​

Vous voulez vérifier ces résultats ? Consultez comment reproduire nos données.

Zéro dépendance​

Chaque kilo-octet que vous ajoutez depuis Pithos est du pur code Pithos : il n'y a pas de dépendances transitives et pas de packages cachés tirés dans votre node_modules. Vous pouvez le vérifier vous-même en inspectant l'arbre de dépendances :

# Arbre de dépendances Pithos
pithos (varies by import)
└── (nothing else)

Cela signifie aussi zéro risque de chaîne d'approvisionnement venant de packages tiers.

Pithos v1.1.0 / Neverthrow v8.2.0 / fp-ts v2.16.11

Related