@duplojs/agents-kit 0.0.0-stage → 0.1.0-beta.6

package/docs/concepts/01-fundamental/01-constraint/20-manipulation.ts

@@ -0,0 +1,41 @@
+/**
+ * @title Manipulation des valeurs contraintes.
+ *
+ * Exploitation des contraintes par les fonctions DuploJS pour simplifier la manipulation des valeurs.
+ */
+import type * as DCommon from "@duplojs/lang/common";
+import * as DTuple from "@duplojs/lang/tuple";
+import * as DString from "@duplojs/lang/string";
+import * as DArray from "@duplojs/lang/array";
+
+// Les primitives exploitent les garanties d’entrée pour préciser leur sortie.
+// Une transformation conserve, adapte ou supprime les contraintes selon ce qui reste vrai.
+declare const userEmail: string & DString.Email;
+
+// Un email dans son format contenant obligatoirement un "@"
+// donne forcément un tableau avec minimum 2 éléments.
+const splitEmail = DString.split(userEmail, "@");
+type _CheckSplitEmail = DCommon.ExpectType<typeof splitEmail, readonly string[] & DArray.MinElements<2>, "strict">;
+
+// Le passage du tableau en tuple est fait en interprétant la contrainte
+// DArray.MinElements<2>, ce qui garantit au moins deux éléments, sans imposer une longueur exacte.
+const [first, second, ...maybeRest] = DTuple.from(splitEmail);
+type _CheckFirst = DCommon.ExpectType<typeof first, string, "strict">;
+type _CheckSecond = DCommon.ExpectType<typeof second, string, "strict">;
+type _CheckMaybeRest = DCommon.ExpectType<typeof maybeRest, string[], "strict">;
+
+// Les accès garantis par la cardinalité évitent le type string | undefined.
+const firstElement = DArray.first(splitEmail);
+type _CheckFirstElement = DCommon.ExpectType<typeof firstElement, string, "strict">;
+
+const lastElement = DArray.last(splitEmail);
+type _CheckLastElement = DCommon.ExpectType<typeof lastElement, string, "strict">;
+
+const secondElement = DArray.at(splitEmail, 1);
+type _CheckSecondElement = DCommon.ExpectType<typeof secondElement, string, "strict">;
+
+const otherElement = DArray.at(splitEmail, 10);
+type _CheckOtherElement = DCommon.ExpectType<typeof otherElement, string | undefined, "strict">;
+
+// Le résultat porte une garantie de cardinalité ; les fragments ne sont plus typés Email.
+// Privilégier les transformations immuables : une mutation pourrait invalider une garantie.

package/docs/concepts/01-fundamental/01-constraint/30-cast.ts

@@ -0,0 +1,66 @@
+/**
+ * @title Compatibilité statique des contraintes.
+ *
+ * Cast par implication, valeurs littérales et inférence en contexte générique.
+ */
+import * as DCommon from "@duplojs/lang/common";
+import type * as DNumber from "@duplojs/lang/number";
+import type * as DString from "@duplojs/lang/string";
+
+// cast restitue la valeur sans validation runtime : TypeScript doit prouver la compatibilité.
+// Il convertit une garantie existante, ou exploite une valeur connue statiquement.
+// Une donnée runtime sans preuve doit d’abord être vérifiée par un predicate.
+declare function myFunction(name: string & DString.MinCharacters<10>): void;
+
+declare const validName: string & DString.MinCharacters<15>;
+// Au moins 15 caractères implique au moins 10 caractères.
+myFunction(DCommon.cast(validName));
+
+declare const invalidName: string & DString.MinCharacters<5>;
+// Erreur de type car la contrainte `DString.MinCharacters<5>`
+// n'induit pas `string & DString.MinCharacters<10>`
+// @ts-expect-error constraint error
+myFunction(DCommon.cast(invalidName));
+
+// De même, une borne strictement inférieure à 10 implique une borne inférieure à 20.
+declare const belowTen: number & DNumber.LessThan<10>;
+const belowTwenty: number & DNumber.LessThan<20> = DCommon.cast(belowTen);
+
+// Les valeurs littérales permettent aussi de calculer la compatibilité sans validation.
+const declaredName: string & DString.MinCharacters<10> = DCommon.cast("thisIsASuperName");
+const declaredAge: number & DNumber.GreaterThanOrEqual<18> = DCommon.cast(20);
+
+declare function myFunctionWithGeneric<
+	GenericName extends string & DString.MinCharacters<10>,
+>(name: GenericName): void;
+
+// Ici, le paramètre générique ne fournit pas à cast un type de retour assez précis.
+// satisfies explicite la cible pour permettre le calcul de compatibilité.
+myFunctionWithGeneric(
+	DCommon.cast("thisIsASuperName") satisfies string & DString.MinCharacters<10>,
+);
+
+// @ts-expect-error cast ne peut pas inférer ici le type de retour attendu.
+myFunctionWithGeneric(DCommon.cast("thisIsASuperName"));
+
+declare function createUser<
+	GenericUser extends {
+		name: string & DString.MinCharacters<10>;
+		age: number & DNumber.GreaterThanOrEqual<18>;
+	},
+>(name: GenericUser): GenericUser;
+
+// infer calcule les contraintes attendues tout en conservant la valeur littérale.
+// Il est adapté aux constantes connues statiquement et ne valide rien au runtime.
+const inferredUser = createUser({
+	name: DCommon.infer("thisIsASuperName"),
+	age: DCommon.infer(18),
+});
+type _CheckInferredUser = DCommon.ExpectType<
+	typeof inferredUser,
+	{
+		name: "thisIsASuperName" & DString.MinCharacters<10>;
+		age: 18 & DNumber.GreaterThanOrEqual<18>;
+	},
+	"strict"
+>;

package/docs/concepts/01-fundamental/01-constraint/40-custom-constraint.ts

@@ -0,0 +1,45 @@
+/**
+ * @title Contraintes personnalisées.
+ *
+ * Déclaration, predicate de validation et extension des règles de cast.
+ */
+import * as DCommon from "@duplojs/lang/common";
+import * as DNumber from "@duplojs/lang/number";
+
+// Étendre Constraint avec un identifiant propre à la propriété modélisée.
+// Cette interface n’ajoute aucun marqueur à la valeur runtime.
+interface Adult extends DCommon.Constraint<"example-adult"> {}
+
+// La signature du predicate doit correspondre à une vérification réelle.
+function isAdult(input: number): input is number & Adult {
+	return DNumber.greaterThanOrEqual(input, 18);
+}
+
+declare const candidate: number;
+if (isAdult(candidate)) {
+	const adult: number & Adult = candidate;
+}
+
+// Les règles de cast peuvent être étendues par augmentation du module common.
+// Cette règle reconnaît la preuve GreaterThanOrEqual<18> comme suffisante pour Adult.
+// Elle ne couvre volontairement pas toutes les autres bornes compatibles.
+declare module "@duplojs/lang/common" {
+	interface ComputeCastConstraintNumberRule<
+		GenericValue extends number,
+		GenericExpectedConstraint extends DCommon.BaseConstraint,
+	> {
+		exampleAdult: GenericExpectedConstraint extends Adult
+			? GenericValue extends DNumber.GreaterThanOrEqual<18>
+				? unknown
+				: DCommon.CastError<"La preuve de majorité est absente.", GenericValue, GenericExpectedConstraint>
+			: never;
+	}
+}
+
+// unknown accepte la compatibilité, CastError la refuse, never ignore les autres cibles.
+// Consulter les interfaces de règles existantes pour étendre les autres domaines.
+declare const verifiedAge: number & DNumber.GreaterThanOrEqual<18>;
+const adultFromProof: number & Adult = DCommon.cast(verifiedAge);
+
+// @ts-expect-error Un nombre sans preuve ne peut pas être converti en Adult.
+const adultWithoutProof: number & Adult = DCommon.cast(candidate);

package/docs/concepts/01-fundamental/01-constraint/index.md

@@ -0,0 +1,3 @@
+## Contraintes de typage
+
+Garanties sur les valeurs : acquisition, composition, propagation, compatibilité statique et contraintes personnalisées.

package/docs/concepts/01-fundamental/02-currying/01-use.ts

@@ -0,0 +1,38 @@
+/**
+ * @title Currification et composition avec pipe.
+ *
+ * Configurer les opérations avant de recevoir la donnée et enchaîner ses transformations.
+ */
+import * as DCommon from "@duplojs/lang/common";
+import * as DArray from "@duplojs/lang/array";
+import * as DString from "@duplojs/lang/string";
+
+// La forme curifiée reçoit les paramètres, puis la donnée transmise par pipe.
+// Si la fonction retournée ne déclare pas ses propres génériques, ses types sont
+// fixés dès l'appel de configuration, même si la surcharge extérieure est générique.
+// Écrire alors l'appel curifié directement comme étape de pipe ou asyncPipe pour
+// fournir le contexte d'inférence attendu. Passer à un pipe une variable contenant
+// une fonction déjà préparée ne déplace pas sa configuration dans ce contexte.
+// Ne pas forcer cette préparation avec des génériques explicites, annotations ou casts.
+// Formater chaque pipe sur plusieurs lignes, un argument par ligne et la fermeture
+// sur sa propre ligne, même avec seulement une donnée et une étape.
+// Privilégier pipe dès qu’une donnée subit plusieurs transformations,
+// ou si le traitement est susceptible d’en accueillir d’autres.
+// Utiliser en priorité les fonctions fournies par l’écosystème.
+const normalizedTags = DCommon.pipe(
+	" TypeScript, DuploJS, Functional " as const,
+	// Configure le séparateur ; pipe fournit ensuite la chaîne.
+	DString.split(","),
+	// Configure la transformation ; pipe fournit le tableau.
+	DArray.map(DString.trim),
+	DArray.filter(DString.isNotEmpty),
+	DArray.map(DString.toLowerCase),
+);
+type _CheckNormalizedTags = DCommon.ExpectType<
+	typeof normalizedTags,
+	readonly (Lowercase<string> & DString.MinCharacters<1>)[] & DArray.MaxElements<3>,
+	"strict"
+>;
+// Résultat : ["typescript", "duplojs", "functional"].
+// Chaque étape reçoit la sortie précédente ; les types suivent ces transformations.
+// On peut ajouter, retirer ou réordonner les étapes sans restructurer le traitement.

package/docs/concepts/01-fundamental/02-currying/10-built-in-function.ts

@@ -0,0 +1,190 @@
+/**
+ * @title Réutilisation des fonctions de l’écosystème dans les pipes.
+ *
+ * Composer les opérations fournies, sous forme curifiée ou directement compatible avec pipe.
+ */
+import * as DCommon from "@duplojs/lang/common";
+import * as DArray from "@duplojs/lang/array";
+import * as DString from "@duplojs/lang/string";
+import * as DObject from "@duplojs/lang/object";
+import * as DNumber from "@duplojs/lang/number";
+import * as DEither from "@duplojs/lang/either";
+import * as DTuple from "@duplojs/lang/tuple";
+import * as DChrono from "@duplojs/lang/chrono";
+import * as DGenerator from "@duplojs/lang/generator";
+import * as DPattern from "@duplojs/lang/pattern";
+import type * as DPath from "@duplojs/lang/path";
+import * as DSFile from "@duplojs/server/file";
+
+// Avant d’écrire une callback ou de recourir à une API native, rechercher une opération
+// fournie par l’écosystème : sa forme curifiée ou son unique argument peut convenir au pipe.
+// Cette démarche s’applique à tous les packages ; les domaines ci-dessous sont des exemples.
+
+// Les fonctions de `string` et `array` sont faites pour être composées.
+const normalizedNames = DCommon.pipe(
+	[" John ", "", " JANE ", " Alice "],
+	DArray.map(DString.trim),
+	DArray.filter(DString.isNotEmpty),
+	DArray.map(DString.toLowerCase),
+	DArray.sort(DString.sortCompare),
+);
+type _CheckNormalizedNames = DCommon.ExpectType<
+	typeof normalizedNames,
+	readonly (Lowercase<string> & DString.MinCharacters<1>)[] & DArray.MaxElements<4>,
+	"strict"
+>;
+
+// Les prédicats de `number` peuvent directement être utilisés
+// dans les fonctions de manipulation de tableaux.
+const adultAges = DCommon.pipe(
+	[12, 18, 42, 8, 21],
+	DArray.filter(DNumber.greaterThanOrEqual(18)),
+	DNumber.sum,
+);
+type _CheckAdultAges = DCommon.ExpectType<typeof adultAges, number, "strict">;
+
+// Les fonctions de `object` sont également prévues pour le pipe.
+const publicUser = DCommon.pipe(
+	{
+		name: " John ",
+		password: "secret",
+		age: 24,
+	},
+	DObject.transformProperty("name", DString.trim),
+	DObject.omit(["password"]),
+);
+type _CheckPublicUser = DCommon.ExpectType<
+	typeof publicUser,
+	{
+		name: string & DString.Trimmed & DString.MaxCharacters<6>;
+		readonly age: 24;
+	},
+	"strict"
+>;
+
+// `innerPipe` permet de composer plusieurs fonctions intégrées
+// directement à l'endroit où une callback est attendue.
+const users = DCommon.pipe(
+	[
+		{
+			name: " John ",
+			age: 24,
+		},
+		{
+			name: " JANE ",
+			age: 32,
+		},
+	],
+	DArray.map(
+		DCommon.innerPipe(
+			DObject.transformProperty(
+				"name",
+				DCommon.innerPipe(
+					DString.trim,
+					DString.toLowerCase,
+				),
+			),
+			DObject.pick(["name"]),
+		),
+	),
+);
+type _CheckUsers = DCommon.ExpectType<
+	typeof users,
+	readonly { name: Lowercase<string> }[] & DArray.LengthEqual<2>,
+	"strict"
+>;
+
+// Les fonctions `Either` sont elles aussi composables avec les pipes.
+declare const maybeName:
+	| DEither.Right<"user-found", string>
+	| DEither.Left<"user-not-found">;
+
+const name = DCommon.pipe(
+	maybeName,
+	DEither.unwrapOr("anonymous"),
+	DString.trim,
+	DString.toLowerCase,
+);
+type _CheckName = DCommon.ExpectType<typeof name, Lowercase<string>, "strict">;
+
+// `Either` possède également ses propres pipes lorsque le traitement
+// doit continuer uniquement sur une valeur `Right`.
+const normalizedEitherName = DEither.rightPipe(
+	maybeName,
+	DString.trim,
+	DString.toLowerCase,
+);
+type _CheckNormalizedEitherName = DCommon.ExpectType<typeof normalizedEitherName, DEither.Left<"user-not-found", unknown> | DEither.Success<Lowercase<string>>, "strict">;
+
+// Les tuples disposent eux aussi de fonctions curifiées.
+const normalizedTuple = DCommon.pipe(
+	[" John ", " Jane "] as const,
+	DTuple.map(DString.trim),
+);
+type _CheckNormalizedTuple = DCommon.ExpectType<typeof normalizedTuple, readonly [string & DString.Trimmed & DString.MaxCharacters<6>, string & DString.Trimmed & DString.MaxCharacters<6>], "strict">;
+
+// Les generators permettent de construire des transformations lazy
+// avec exactement le même modèle de composition.
+const generatedNames = DCommon.pipe(
+	[" John ", "", " JANE ", " Alice "],
+	DGenerator.map(DString.trim),
+	DGenerator.filter(DString.isNotEmpty),
+	DGenerator.map(DString.toLowerCase),
+	DArray.from,
+);
+type _CheckGeneratedNames = DCommon.ExpectType<typeof generatedNames, readonly (Lowercase<string> & DString.MinCharacters<1>)[], "strict">;
+
+// Les fonctions de date peuvent être utilisées directement dans les pipes.
+declare const creationDate: DChrono.TheDate;
+
+const serializedCreationDate = DCommon.pipe(
+	creationDate,
+	DChrono.formatDate(
+		"YYYY-MM-DD HH:mm:ss",
+		"Europe/Paris",
+	),
+);
+type _CheckSerializedCreationDate = DCommon.ExpectType<typeof serializedCreationDate, string, "strict">;
+
+// Le pattern matching fournit également des fonctions curifiées.
+declare const status: "draft" | "published" | "archived";
+
+const statusLabel = DCommon.pipe(
+	status,
+	DPattern.matchWithStringOtherwise(
+		{
+			draft: () => "Draft" as const,
+			published: () => "Published" as const,
+		},
+		() => "Archived" as const,
+	),
+);
+type _CheckStatusLabel = DCommon.ExpectType<typeof statusLabel, "Draft" | "Published" | "Archived", "strict">;
+
+// Les fonctions n'ont pas besoin d'être curifiées lorsqu'elles reçoivent
+// déjà la donnée comme unique argument : elles peuvent être utilisées
+// directement comme étape du pipe.
+declare const filePath: string & DPath.Path;
+
+const fileContent = await DCommon.asyncPipe(
+	filePath,
+	DSFile.readTextFile,
+	DEither.unwrapOr(""),
+	DString.trim,
+);
+type _CheckFileContent = DCommon.ExpectType<typeof fileContent, string & DString.Trimmed, "strict">;
+
+// Les fonctions curifiées existent également dans `@duplojs/server`.
+const writeResult = await DCommon.asyncPipe(
+	filePath,
+	DSFile.writeTextFile("Hello world"),
+);
+type _CheckWriteResult = DCommon.ExpectType<typeof writeResult, DSFile.WriteTextFileResult, "strict">;
+
+// Cela permet de composer des traitements provenant de plusieurs packages.
+const jsonContent = await DCommon.asyncPipe(
+	filePath,
+	DSFile.readJsonFile,
+	DEither.unwrapOr({}),
+);
+type _CheckJsonContent = DCommon.ExpectType<typeof jsonContent, DCommon.Json | {}, "strict">;

package/docs/concepts/01-fundamental/02-currying/20-inner-pipe.ts

@@ -0,0 +1,48 @@
+/**
+ * @title Composition dans une callback.
+ *
+ * Enchaîner des transformations lorsque la fonction appelante attend une fonction.
+ */
+import * as DCommon from "@duplojs/lang/common";
+import * as DArray from "@duplojs/lang/array";
+import * as DString from "@duplojs/lang/string";
+import type * as DNumber from "@duplojs/lang/number";
+
+// `innerPipe` permet d'enchaîner plusieurs transformations lorsqu'une
+// fonction de transformation est elle-même attendue.
+//
+const normalizedTagsWithInnerPipe = DCommon.pipe(
+	" TypeScript, DuploJS, Functional " as const,
+	DString.split(","),
+	DArray.map(
+		DCommon.innerPipe(
+			DString.trim,
+			DString.toLowerCase,
+		),
+	),
+	DArray.filter(DString.isNotEmpty),
+);
+type _CheckNormalizedTagsWithInnerPipe = DCommon.ExpectType<
+	typeof normalizedTagsWithInnerPipe,
+	readonly (Lowercase<string> & DString.NotEmpty)[] & DArray.MaxElements<3>,
+	"strict"
+>;
+
+// `innerPipe` évite de créer une callback intermédiaire uniquement
+// pour enchaîner plusieurs transformations.
+//
+const tagLengths = DCommon.pipe(
+	" TypeScript, DuploJS, Functional " as const,
+	DString.split(","),
+	DArray.map(
+		DCommon.innerPipe(
+			DString.trim,
+			DString.length,
+		),
+	),
+);
+type _CheckTagLengths = DCommon.ExpectType<
+	typeof tagLengths,
+	readonly (number & DNumber.Positive)[] & DArray.LengthEqual<3> & DArray.MinElements<3> & DArray.MaxElements<3>,
+	"strict"
+>;

package/docs/concepts/01-fundamental/02-currying/30-async-pipe.ts

@@ -0,0 +1,51 @@
+/**
+ * @title Composition de traitements asynchrones.
+ *
+ * Enchaîner des étapes synchrones et asynchrones dans un pipe ou une callback.
+ */
+import * as DCommon from "@duplojs/lang/common";
+import * as DArray from "@duplojs/lang/array";
+import * as DString from "@duplojs/lang/string";
+
+// `asyncPipe` applique le même principe lorsqu'une ou plusieurs étapes
+// du traitement sont asynchrones.
+//
+const asyncTags = DCommon.asyncPipe(
+	Promise.resolve(" TypeScript, DuploJS " as const),
+	DString.split(","),
+	DArray.map(DString.trim),
+	(tags) => Promise.resolve(tags),
+	DArray.map(DString.toLowerCase),
+);
+type _CheckAsyncTags = DCommon.ExpectType<
+	typeof asyncTags,
+	Promise<readonly Lowercase<string>[] & DArray.LengthEqual<2> & DArray.MinElements<2> & DArray.MaxElements<2>>,
+	"strict"
+>;
+
+// `asyncInnerPipe` permet de composer plusieurs transformations synchrones
+// ou asynchrones lorsqu'une callback asynchrone est attendue.
+//
+// map produit ici un tableau de promesses ; asyncPipe attend chaque étape, pas chaque élément.
+const values = DCommon.asyncPipe(
+	[" TypeScript ", " DuploJS "] as const,
+	DArray.map(
+		DCommon.asyncInnerPipe(
+			(value) => Promise.resolve(value),
+			DString.trim,
+			DString.toLowerCase,
+		),
+	),
+);
+type _CheckValues = DCommon.ExpectType<
+	typeof values,
+	Promise<readonly Promise<Lowercase<string>>[] & DArray.LengthEqual<2>>,
+	"strict"
+>;
+
+// Pour récupérer les valeurs résolues, ajouter une étape qui attend toutes les promesses.
+const resolvedValues = DCommon.asyncPipe(
+	values,
+	DCommon.promiseAll,
+);
+type _CheckResolvedValues = DCommon.ExpectType<typeof resolvedValues, Promise<Lowercase<string>[]>, "strict">;

package/docs/concepts/01-fundamental/02-currying/index.md

@@ -0,0 +1,3 @@
+## Currification
+
+Composition des transformations de données avec les fonctions DuploJS : pipes, callbacks et traitements asynchrones.

package/docs/concepts/01-fundamental/03-either/01-use.ts

@@ -0,0 +1,21 @@
+/**
+ * @title Représentation des résultats avec Either.
+ *
+ * Statuts Right et Left, information contextuelle et valeur associée.
+ */
+import * as DEither from "@duplojs/lang/either";
+
+// Un résultat porte un statut, une information qui identifie le cas et une valeur.
+const result = DEither.right("user-found", { name: "Alice" });
+const missing = DEither.left("user-not-found");
+
+// Les variantes fournies reposent sur Right (Success, Some, Result, Ok) ou Left
+// (Fail, Error, None).
+// Result décrit un état contextualisé sans décider s’il constitue un succès ou un échec.
+// Un contrat exprime les résultats possibles par une union, avec des informations
+// personnalisées ou des variantes fournies.
+// Dès qu'une branche d'une fonction renvoie un Right ou un Left, toutes ses
+// branches renvoient un Either. Envelopper les valeurs de réussite dans un Right,
+// y compris avec ok() pour une réussite sans valeur ; ne pas mélanger des Either
+// et des valeurs brutes dans le contrat de retour.
+type FindUserResult = DEither.Right<"user-found", { name: "Alice" }> | DEither.Left<"user-not-found", undefined>;

package/docs/concepts/01-fundamental/03-either/10-discrimination.ts

@@ -0,0 +1,90 @@
+/**
+ * @title Discrimination et extraction des résultats.
+ *
+ * Choisir une branche par statut ou information, extraire sa valeur et traiter les autres cas.
+ */
+import * as DEither from "@duplojs/lang/either";
+import * as DCommon from "@duplojs/lang/common";
+
+declare const myResult: (
+	| DEither.Success<"result">
+	| DEither.Left<"fail-task", Error>
+	| DEither.Fail
+	| DEither.Error<Error>
+);
+
+// Choisir Right ou Left lorsque seul le statut du résultat compte.
+// whenIsRight transforme la valeur contenue dans un Right et transmet les Left tels quels.
+const resultWhenIsRight = DCommon.pipe(
+	myResult,
+	DEither.whenIsRight(
+		(rightValue) => rightValue,
+	),
+);
+type _CheckResultWhenIsRight = DCommon.ExpectType<
+	typeof resultWhenIsRight,
+	"result" | DEither.Left<"fail-task", Error> | DEither.Fail | DEither.Error<Error>,
+	"strict"
+>;
+const resultUnwrapLeft = DEither.unwrapLeft(myResult);
+// unwrapLeft extrait la valeur des Left et conserve les autres résultats enveloppés.
+
+// Choisir une information lorsque le cas précis compte, quel que soit son statut.
+// La callback reçoit ici l’Error contenue dans le Left "fail-task".
+const resultWhenHasInformation = DCommon.pipe(
+	myResult,
+	DEither.whenHasInformation(
+		"fail-task",
+		(error) => "test" as const,
+	),
+);
+type _CheckResultWhenHasInformation = DCommon.ExpectType<
+	typeof resultWhenHasInformation,
+	DEither.Success<"result"> | DEither.Fail | DEither.Error<Error> | "test",
+	"strict"
+>;
+const resultUnwrapByInformation = DCommon.pipe(
+	myResult,
+	DEither.unwrapByInformation(
+		["success", "fail-task"],
+	),
+);
+type _CheckResultUnwrapByInformation = DCommon.ExpectType<typeof resultUnwrapByInformation, "result" | Error | DEither.Fail | DEither.Error<Error>, "strict">;
+// Les variantes non ciblées sont conservées dans le résultat et dans son type.
+
+// Les variantes Otherwise traitent aussi les cas non ciblés, au lieu de les transmettre.
+const resultWhenIsRightOtherwise = DCommon.pipe(
+	myResult,
+	DEither.whenIsRightOtherwise(
+		(rightValue) => {
+			type _CheckRightValue = DCommon.ExpectType<typeof rightValue, "result", "strict">;
+			return "right" as const;
+		},
+		(leftResult) => {
+			type _CheckLeftResult = DCommon.ExpectType<typeof leftResult, DEither.Left<"fail-task", Error> | DEither.Fail | DEither.Error<Error>, "strict">;
+			return "left" as const;
+		},
+	),
+);
+type _CheckResultWhenIsRightOtherwise = DCommon.ExpectType<typeof resultWhenIsRightOtherwise, "right" | "left", "strict">;
+
+// Les variantes OrThrow extraient les cas ciblés et lèvent une exception pour les autres.
+const resultUnwrapByInformationOrThrow = DCommon.pipe(
+	myResult,
+	DEither.unwrapByInformationOrThrow(
+		["success", "fail-task"],
+	),
+);
+type _CheckResultUnwrapByInformationOrThrow = DCommon.ExpectType<typeof resultUnwrapByInformationOrThrow, "result" | Error, "strict">;
+// Utile notamment pour affirmer le résultat attendu dans un test unitaire.
+
+// Les predicates réduisent le type dans une branche conditionnelle.
+if (DEither.hasInformation(myResult, "success")) {
+	type _CheckSuccessResult = DCommon.ExpectType<typeof myResult, DEither.Success<"result">, "strict">;
+	void myResult;
+}
+// isRight et isLeft réduisent aussi le type selon le statut du résultat.
+if (DEither.isLeft(myResult)) {
+	const leftValue = DEither.unwrapLeft(myResult);
+	void leftValue;
+}