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

package/docs/API/10-lang/10-either/10-asyncGroup.ts

@@ -0,0 +1,44 @@
+/**
+ * @title DEither.asyncGroup
+ *
+ * Regrouper séquentiellement des résultats synchrones ou asynchrones dans un Success.
+ */
+import * as DEither from "@duplojs/lang/either";
+import type * as DCommon from "@duplojs/lang/common";
+
+const objectResult = DEither.asyncGroup({
+	user: () => Promise.resolve(DEither.success("Alice")),
+	count: DEither.success(2),
+});
+
+// La sortie attend chaque entrée et regroupe les valeurs déballées dans une Promise.
+type _CheckObject = DCommon.ExpectType<
+	typeof objectResult,
+	Promise<DEither.Success<{
+		user: "Alice";
+		count: 2;
+	}>>,
+	"strict"
+>;
+
+// Le premier Left est retourné et les getters placés après lui ne sont pas exécutés.
+const errorResult = DEither.asyncGroup({
+	user: () => Promise.resolve(DEither.success("Alice")),
+	error: () => Promise.resolve(DEither.error("user-not-found")),
+	skipped: () => Promise.resolve(DEither.success(2)),
+});
+type _CheckError = DCommon.ExpectType<
+	typeof errorResult,
+	Promise<DEither.Error<"user-not-found"> | DEither.Success<{
+		user: "Alice";
+		error: never;
+		skipped: 2;
+	}>>,
+	"strict"
+>;
+
+const tupleResult = DEither.asyncGroup([
+	() => Promise.resolve(DEither.success("Alice")),
+	() => Promise.resolve(DEither.success(2)),
+]);
+type _CheckTuple = DCommon.ExpectType<typeof tupleResult, Promise<DEither.Success<["Alice", 2]>>, "strict">;

package/docs/API/10-lang/10-either/10-asyncSafeCallback.ts

@@ -0,0 +1,25 @@
+/**
+ * @title DEither.asyncSafeCallback
+ *
+ * Convertir une callback ou une promesse et ses exceptions en résultat asynchrone.
+ */
+import * as DEither from "@duplojs/lang/either";
+import type * as DCommon from "@duplojs/lang/common";
+
+declare const saved: "saved";
+const result = DEither.asyncSafeCallback(() => Promise.resolve(saved));
+
+// La sortie est toujours une Promise et inclut le Left standard des erreurs capturées.
+type _CheckResult = DCommon.ExpectType<
+	typeof result,
+	Promise<DEither.SafeCallbackSuccess<"saved"> | DEither.SafeCallbackError>,
+	"strict"
+>;
+
+const savedPromise = Promise.resolve(saved);
+const promiseInput = DEither.asyncSafeCallback(savedPromise);
+type _CheckPromiseInput = DCommon.ExpectType<
+	typeof promiseInput,
+	Promise<DEither.SafeCallbackSuccess<"saved"> | DEither.SafeCallbackError>,
+	"strict"
+>;

package/docs/API/10-lang/10-either/10-error.ts

@@ -0,0 +1,12 @@
+/**
+ * @title DEither.error
+ *
+ * Créer un Left standardisé avec l’information `error`.
+ */
+import * as DEither from "@duplojs/lang/either";
+import type * as DCommon from "@duplojs/lang/common";
+
+const result = DEither.error("connection-failed");
+
+// La sortie est un Left portant l’information littérale "error".
+type _CheckResult = DCommon.ExpectType<typeof result, DEither.Error<"connection-failed">, "strict">;

package/docs/API/10-lang/10-either/10-expect.ts

@@ -0,0 +1,13 @@
+/**
+ * @title DEither.expect
+ *
+ * Retourner un Either sans modifier sa valeur ni son type.
+ */
+import * as DEither from "@duplojs/lang/either";
+import type * as DCommon from "@duplojs/lang/common";
+
+const input = DEither.success("saved");
+const result = DEither.expect(input);
+
+// La sortie conserve exactement le Right fourni en entrée.
+type _CheckResult = DCommon.ExpectType<typeof result, DEither.Success<"saved">, "strict">;

package/docs/API/10-lang/10-either/10-extractErrorInLeft.ts

@@ -0,0 +1,45 @@
+/**
+ * @title DEither.extractErrorInLeft
+ *
+ * Extraire d’un Left les erreurs DuploJS sélectionnées par leur identifiant.
+ */
+import * as DEither from "@duplojs/lang/either";
+import * as DCommon from "@duplojs/lang/common";
+
+class MissingError extends DCommon.DuploJSError.parentClass("missing") {}
+class ForbiddenError extends DCommon.DuploJSError.parentClass("forbidden") {}
+class UnexpectedError extends DCommon.DuploJSError.parentClass("unexpected") {}
+
+type LoadResult = (
+	| DEither.Left<"load-error", MissingError | ForbiddenError | UnexpectedError>
+	| DEither.Right<"success", string>
+	| null
+);
+
+declare const result: LoadResult;
+
+// Appel classique : l’erreur sélectionnée reçoit son identifiant comme information.
+const extracted = DEither.extractErrorInLeft(result, "missing");
+type _CheckExtracted = DCommon.ExpectType<
+	typeof extracted,
+	| DEither.Left<"load-error", ForbiddenError | UnexpectedError>
+	| DEither.Left<"missing", MissingError>
+	| DEither.Right<"success", string>
+	| null,
+	"strict"
+>;
+
+// Appel curifié : extraire plusieurs erreurs avant de traiter l’erreur restante.
+const separated = DCommon.pipe(
+	result,
+	DEither.extractErrorInLeft(["missing", "forbidden"]),
+);
+type _CheckSeparated = DCommon.ExpectType<
+	typeof separated,
+	| DEither.Left<"load-error", UnexpectedError>
+	| DEither.Left<"missing", MissingError>
+	| DEither.Left<"forbidden", ForbiddenError>
+	| DEither.Right<"success", string>
+	| null,
+	"strict"
+>;

package/docs/API/10-lang/10-either/10-fail.ts

@@ -0,0 +1,12 @@
+/**
+ * @title DEither.fail
+ *
+ * Créer un Left standardisé représentant un échec sans valeur.
+ */
+import * as DEither from "@duplojs/lang/either";
+import type * as DCommon from "@duplojs/lang/common";
+
+const result = DEither.fail();
+
+// La sortie est `Fail`, un Left dont la valeur est `undefined`.
+type _CheckResult = DCommon.ExpectType<typeof result, DEither.Fail, "strict">;

package/docs/API/10-lang/10-either/10-forwardAssertsSelection.ts

@@ -0,0 +1,28 @@
+/**
+ * @title DEither.forwardAssertsSelection
+ *
+ * Affirmer qu’une information est sélectionnée et lever une exception sinon.
+ */
+import * as DEither from "@duplojs/lang/either";
+import * as DCommon from "@duplojs/lang/common";
+
+declare const input: DEither.Success<"saved"> | DEither.Left<"missing", Error>;
+
+// Appel classique : le type est réduit aux informations sélectionnées.
+const direct = DEither.forwardAssertsSelection(input, {
+	success: true,
+	missing: false,
+});
+type _CheckDirect = DCommon.ExpectType<typeof direct, DEither.Success<"saved">, "strict">;
+
+// Appel curifié : l’affirmation est placée dans le pipe.
+const piped = DCommon.pipe(
+	input,
+	DEither.forwardAssertsSelection({
+		success: true,
+		missing: false,
+	}),
+);
+type _CheckPiped = DCommon.ExpectType<typeof piped, DEither.Success<"saved">, "strict">;
+
+// Une information marquée `false` provoque `ForwardAssertsSelectionError` au runtime.

package/docs/API/10-lang/10-either/10-group.ts

@@ -0,0 +1,58 @@
+/**
+ * @title DEither.group
+ *
+ * Regrouper des Right dans un Success en arrêtant au premier Left.
+ */
+import * as DEither from "@duplojs/lang/either";
+import type * as DCommon from "@duplojs/lang/common";
+
+// La forme objet conserve les clés et déballe les valeurs des Right.
+const objectResult = DEither.group({
+	user: DEither.success("Alice"),
+	count: DEither.success(2),
+});
+type _CheckObject = DCommon.ExpectType<
+	typeof objectResult,
+	DEither.Success<{
+		user: "Alice";
+		count: 2;
+	}>,
+	"strict"
+>;
+
+// Les getters permettent de différer le calcul de chaque résultat.
+const withGetters = DEither.group({
+	user: () => DEither.success("Alice"),
+	count: () => DEither.success(2),
+});
+type _CheckGetters = DCommon.ExpectType<
+	typeof withGetters,
+	DEither.Success<{
+		user: "Alice";
+		count: 2;
+	}>,
+	"strict"
+>;
+
+// Le premier Left est retourné et les getters placés après lui ne sont pas exécutés.
+const errorResult = DEither.group({
+	user: () => DEither.success("Alice"),
+	error: () => DEither.error("user-not-found"),
+	skipped: () => DEither.success(2),
+});
+type _CheckError = DCommon.ExpectType<
+	typeof errorResult,
+	DEither.Error<"user-not-found"> | DEither.Success<{
+		user: "Alice";
+		error: never;
+		skipped: 2;
+	}>,
+	"strict"
+>;
+
+const tupleResult = DEither.group([
+	DEither.success("Alice"),
+	DEither.success(2),
+]);
+// La forme tuple conserve sa longueur et déballe chaque Right.
+type _CheckTuple = DCommon.ExpectType<typeof tupleResult, DEither.Success<["Alice", 2]>, "strict">;

package/docs/API/10-lang/10-either/10-hasInformation.ts

@@ -0,0 +1,30 @@
+/**
+ * @title DEither.hasInformation
+ *
+ * Tester l’information d’un Either et affiner le statut et la valeur.
+ */
+import * as DEither from "@duplojs/lang/either";
+import * as DCommon from "@duplojs/lang/common";
+
+declare const input: DEither.Success<"saved"> | DEither.Left<"missing", Error>;
+
+if (DEither.hasInformation(input, "missing")) {
+	type _CheckInput = DCommon.ExpectType<typeof input, DEither.Left<"missing", Error>, "strict">;
+	const reason = DEither.unwrapLeft(input);
+	type _CheckReason = DCommon.ExpectType<typeof reason, Error, "strict">;
+}
+
+// La forme curifiée est directement utilisable comme predicate de DCommon.when.
+const result = DCommon.pipe(
+	input,
+	DCommon.when(
+		DEither.hasInformation("missing"),
+		DEither.unwrapLeft,
+	),
+);
+
+// Le cas ciblé devient Error ; le cas non ciblé conserve son Right.
+type _CheckResult = DCommon.ExpectType<typeof result, Error | DEither.Success<"saved">, "strict">;
+
+const matches = DEither.hasInformation(DEither.success("saved"), "success");
+type _CheckMatches = DCommon.ExpectType<typeof matches, boolean, "strict">;

package/docs/API/10-lang/10-either/10-isLeft.ts

@@ -0,0 +1,25 @@
+/**
+ * @title DEither.isLeft
+ *
+ * Vérifier le statut Left et affiner le type de la valeur.
+ */
+import * as DEither from "@duplojs/lang/either";
+import * as DCommon from "@duplojs/lang/common";
+
+declare const input: DEither.Success<"saved"> | DEither.Left<"missing", Error>;
+
+if (DEither.isLeft(input)) {
+	// Dans cette branche, seul le Left reste possible.
+	type _CheckInput = DCommon.ExpectType<typeof input, DEither.Left<"missing", Error>, "strict">;
+	const value = DEither.unwrapLeft(input);
+	type _CheckValue = DCommon.ExpectType<typeof value, Error, "strict">;
+}
+
+const result = DCommon.pipe(
+	input,
+	DCommon.when(
+		DEither.isLeft,
+		DEither.unwrapLeft,
+	),
+);
+type _CheckResult = DCommon.ExpectType<typeof result, Error | DEither.Success<"saved">, "strict">;

package/docs/API/10-lang/10-either/10-isRight.ts

@@ -0,0 +1,25 @@
+/**
+ * @title DEither.isRight
+ *
+ * Vérifier le statut Right et affiner le type de la valeur.
+ */
+import * as DEither from "@duplojs/lang/either";
+import * as DCommon from "@duplojs/lang/common";
+
+declare const input: DEither.Success<"saved"> | DEither.Left<"missing", Error>;
+
+if (DEither.isRight(input)) {
+	// Dans cette branche, seul le Right reste possible.
+	type _CheckInput = DCommon.ExpectType<typeof input, DEither.Success<"saved">, "strict">;
+	const value = DEither.unwrapRight(input);
+	type _CheckValue = DCommon.ExpectType<typeof value, "saved", "strict">;
+}
+
+const result = DCommon.pipe(
+	input,
+	DCommon.when(
+		DEither.isRight,
+		DEither.unwrapRight,
+	),
+);
+type _CheckResult = DCommon.ExpectType<typeof result, "saved" | DEither.Left<"missing", Error>, "strict">;

package/docs/API/10-lang/10-either/10-isSelected.ts

@@ -0,0 +1,41 @@
+/**
+ * @title DEither.isSelected
+ *
+ * Tester une sélection d’informations et affiner l’union d’Either.
+ */
+import * as DEither from "@duplojs/lang/either";
+import * as DCommon from "@duplojs/lang/common";
+
+declare const input: DEither.Success<"saved"> | DEither.Left<"missing", Error>;
+
+if (DEither.isSelected(input, {
+	success: true,
+	missing: false,
+})) {
+	type _CheckInput = DCommon.ExpectType<typeof input, DEither.Success<"saved">, "strict">;
+	const value = DEither.unwrapRight(input);
+	type _CheckValue = DCommon.ExpectType<typeof value, "saved", "strict">;
+}
+
+// La forme curifiée est directement utilisable comme predicate de DCommon.when.
+const result = DCommon.pipe(
+	input,
+	DCommon.when(
+		DEither.isSelected({
+			success: true,
+			missing: false,
+		}),
+		DEither.unwrapRight,
+	),
+);
+
+// Le cas sélectionné est extrait ; le Left non sélectionné reste enveloppé.
+type _CheckResult = DCommon.ExpectType<typeof result, "saved" | DEither.Left<"missing", Error>, "strict">;
+
+const matches = DEither.isSelected(
+	DEither.left("missing", new Error("missing")),
+	{
+		missing: true,
+	},
+);
+type _CheckMatches = DCommon.ExpectType<typeof matches, boolean, "strict">;

package/docs/API/10-lang/10-either/10-keepAsRightByInformation.ts

@@ -0,0 +1,29 @@
+/**
+ * @title DEither.keepAsRightByInformation
+ *
+ * Reclasser comme Right les variantes portant certaines informations.
+ */
+import * as DEither from "@duplojs/lang/either";
+import * as DCommon from "@duplojs/lang/common";
+
+const input = DEither.left("validated", "Alice");
+
+// Appel classique : l’information ciblée devient un Right.
+const direct = DEither.keepAsRightByInformation(input, "validated");
+type _CheckDirect = DCommon.ExpectType<typeof direct, DEither.Right<"validated", "Alice">, "strict">;
+
+// Appel curifié : le changement de statut est placé dans le pipe.
+const piped = DCommon.pipe(
+	input,
+	DEither.keepAsRightByInformation("validated"),
+);
+type _CheckPiped = DCommon.ExpectType<typeof piped, DEither.Right<"validated", "Alice">, "strict">;
+
+// Un Right dont l’information n’est pas ciblée devient un Left ; les informations
+// impossibles pour l’union d’entrée doivent être déclarées explicitement au runtime.
+const rejected = DEither.keepAsRightByInformation(DEither.right("other", 42), "selected" as never);
+type _CheckRejected = DCommon.ExpectType<
+	typeof rejected,
+	DEither.Left<"other", 42>,
+	"strict"
+>;

package/docs/API/10-lang/10-either/10-keepAsRightSelection.ts

@@ -0,0 +1,23 @@
+/**
+ * @title DEither.keepAsRightSelection
+ *
+ * Reclasser les variantes selon une sélection exhaustive d’informations.
+ */
+import * as DEither from "@duplojs/lang/either";
+import * as DCommon from "@duplojs/lang/common";
+
+const input = DEither.left("validated", "Alice");
+
+// Appel classique : la variante sélectionnée devient Right.
+const direct = DEither.keepAsRightSelection(input, { validated: true });
+type _CheckDirect = DCommon.ExpectType<typeof direct, DEither.Right<"validated", "Alice">, "strict">;
+
+// Appel curifié : la sélection est placée dans le pipe.
+const piped = DCommon.pipe(
+	input,
+	DEither.keepAsRightSelection({ validated: true }),
+);
+type _CheckPiped = DCommon.ExpectType<typeof piped, DEither.Right<"validated", "Alice">, "strict">;
+
+const rejected = DEither.keepAsRightSelection(DEither.success("saved"), { success: false });
+type _CheckRejected = DCommon.ExpectType<typeof rejected, DEither.Left<"success", "saved">, "strict">;

package/docs/API/10-lang/10-either/10-left.ts

@@ -0,0 +1,13 @@
+/**
+ * @title DEither.left
+ *
+ * Créer un résultat Left avec une information et une valeur optionnelle.
+ */
+import * as DEither from "@duplojs/lang/either";
+import type * as DCommon from "@duplojs/lang/common";
+
+const withoutValue = DEither.left("missing");
+type _CheckWithoutValue = DCommon.ExpectType<typeof withoutValue, DEither.Left<"missing", undefined>, "strict">;
+
+const withValue = DEither.left("invalid", "bad-input");
+type _CheckWithValue = DCommon.ExpectType<typeof withValue, DEither.Left<"invalid", "bad-input">, "strict">;

package/docs/API/10-lang/10-either/10-matchInformation.ts

@@ -0,0 +1,28 @@
+/**
+ * @title DEither.matchInformation
+ *
+ * Appliquer exhaustivement une callback selon l’information du résultat.
+ */
+import * as DEither from "@duplojs/lang/either";
+import * as DCommon from "@duplojs/lang/common";
+
+declare const input: DEither.Success<"saved"> | DEither.Left<"missing", Error>;
+declare const stored: "stored";
+declare const rejected: "rejected";
+
+// Appel classique : chaque information de l’union possède une callback.
+const direct = DEither.matchInformation(input, {
+	success: (value) => stored,
+	missing: (value) => rejected,
+});
+type _CheckDirect = DCommon.ExpectType<typeof direct, "stored" | "rejected", "strict">;
+
+// Appel curifié : le matcher est directement placé dans le pipe.
+const piped = DCommon.pipe(
+	input,
+	DEither.matchInformation({
+		success: (value) => stored,
+		missing: (value) => rejected,
+	}),
+);
+type _CheckPiped = DCommon.ExpectType<typeof piped, "stored" | "rejected", "strict">;

package/docs/API/10-lang/10-either/10-matchInformationCombination.ts

@@ -0,0 +1,61 @@
+/**
+ * @title DEither.matchInformationCombination
+ *
+ * Appliquer un traitement pour chaque combinaison d’informations d’une collection d’Either.
+ */
+import * as DEither from "@duplojs/lang/either";
+import * as DCommon from "@duplojs/lang/common";
+
+type Combination = readonly [
+	DEither.Success<42> | DEither.Error<"message">,
+	DEither.Right<"found", 1> | DEither.Left<"missing", undefined>,
+];
+
+declare const combination: Combination;
+
+// Appel classique : les quatre combinaisons possibles sont traitées explicitement.
+const direct = DEither.matchInformationCombination(combination, {
+	"success/found": (values) => {
+		type _CheckValues = DCommon.ExpectType<typeof values, readonly [42, 1], "strict">;
+		return values;
+	},
+	"success/missing": (values) => {
+		type _CheckValues = DCommon.ExpectType<typeof values, readonly [42, undefined], "strict">;
+		return values;
+	},
+	"error/found": (values) => {
+		type _CheckValues = DCommon.ExpectType<typeof values, readonly ["message", 1], "strict">;
+		return values;
+	},
+	"error/missing": (values) => {
+		type _CheckValues = DCommon.ExpectType<typeof values, readonly ["message", undefined], "strict">;
+		return values;
+	},
+});
+type _CheckDirect = DCommon.ExpectType<
+	typeof direct,
+	| readonly [42, 1]
+	| readonly [42, undefined]
+	| readonly ["message", 1]
+	| readonly ["message", undefined],
+	"strict"
+>;
+
+// Appel curifié : le matcher exhaustif est directement placé dans le pipe.
+const piped = DCommon.pipe(
+	combination,
+	DEither.matchInformationCombination({
+		"success/found": (values) => values,
+		"success/missing": (values) => values,
+		"error/found": (values) => values,
+		"error/missing": (values) => values,
+	}),
+);
+type _CheckPiped = DCommon.ExpectType<
+	typeof piped,
+	| readonly [42, 1]
+	| readonly [42, undefined]
+	| readonly ["message", 1]
+	| readonly ["message", undefined],
+	"strict"
+>;

package/docs/API/10-lang/10-either/10-matchInformationCombinationOtherwise.ts

@@ -0,0 +1,62 @@
+/**
+ * @title DEither.matchInformationCombinationOtherwise
+ *
+ * Traiter les combinaisons d’informations choisies et fournir un cas de repli.
+ */
+import * as DEither from "@duplojs/lang/either";
+import * as DCommon from "@duplojs/lang/common";
+
+type Combination = readonly [
+	DEither.Success<42> | DEither.Error<"message">,
+	DEither.Right<"found", 1> | DEither.Left<"missing", undefined>,
+];
+
+declare const combination: Combination;
+
+// Appel classique : traiter success/found et transmettre les autres cas au repli.
+const direct = DEither.matchInformationCombinationOtherwise(
+	combination,
+	{
+		"success/found": (values) => {
+			type _CheckValues = DCommon.ExpectType<typeof values, readonly [42, 1], "strict">;
+			return values;
+		},
+	},
+	(values) => {
+		type _CheckRemaining = DCommon.ExpectType<
+			typeof values,
+			| readonly [DEither.Success<42>, DEither.Left<"missing", undefined>]
+			| readonly [DEither.Error<"message">, DEither.Right<"found", 1>]
+			| readonly [DEither.Error<"message">, DEither.Left<"missing", undefined>],
+			"strict"
+		>;
+		return values;
+	},
+);
+type _CheckDirect = DCommon.ExpectType<
+	typeof direct,
+	| readonly [42, 1]
+	| readonly [DEither.Success<42>, DEither.Left<"missing", undefined>]
+	| readonly [DEither.Error<"message">, DEither.Right<"found", 1>]
+	| readonly [DEither.Error<"message">, DEither.Left<"missing", undefined>],
+	"strict"
+>;
+
+// Appel curifié : la sélection et le repli sont configurés dans le pipe.
+const piped = DCommon.pipe(
+	combination,
+	DEither.matchInformationCombinationOtherwise(
+		{
+			"error/missing": (values) => values,
+		},
+		(values) => values,
+	),
+);
+type _CheckPiped = DCommon.ExpectType<
+	typeof piped,
+	| readonly [DEither.Success<42>, DEither.Right<"found", 1>]
+	| readonly [DEither.Success<42>, DEither.Left<"missing", undefined>]
+	| readonly [DEither.Error<"message">, DEither.Right<"found", 1>]
+	| readonly ["message", undefined],
+	"strict"
+>;

package/docs/API/10-lang/10-either/10-matchInformationOtherwise.ts

@@ -0,0 +1,29 @@
+/**
+ * @title DEither.matchInformationOtherwise
+ *
+ * Appliquer une callback pour certaines informations et une branche de repli pour les autres.
+ */
+import * as DEither from "@duplojs/lang/either";
+import * as DCommon from "@duplojs/lang/common";
+
+declare const input: DEither.Success<"saved"> | DEither.Left<"missing", Error>;
+declare const stored: "stored";
+declare const unhandled: "unhandled";
+
+// Appel classique : seules les informations documentées dans le matcher sont ciblées.
+const direct = DEither.matchInformationOtherwise(
+	input,
+	{ success: (value: "saved") => stored },
+	(value) => unhandled,
+);
+type _CheckDirect = DCommon.ExpectType<typeof direct, "stored" | "unhandled", "strict">;
+
+// Appel curifié : le matcher et la branche de repli sont configurés dans le pipe.
+const piped = DCommon.pipe(
+	input,
+	DEither.matchInformationOtherwise(
+		{ success: (value: "saved") => stored },
+		(value) => unhandled,
+	),
+);
+type _CheckPiped = DCommon.ExpectType<typeof piped, "stored" | "unhandled", "strict">;

package/docs/API/10-lang/10-either/10-none.ts

@@ -0,0 +1,12 @@
+/**
+ * @title DEither.none
+ *
+ * Créer le Left représentant l’absence d’une valeur.
+ */
+import * as DEither from "@duplojs/lang/either";
+import type * as DCommon from "@duplojs/lang/common";
+
+const result = DEither.none();
+
+// La sortie est `None`, un Left dont la valeur est `null`.
+type _CheckResult = DCommon.ExpectType<typeof result, DEither.None, "strict">;

package/docs/API/10-lang/10-either/10-ok.ts

@@ -0,0 +1,12 @@
+/**
+ * @title DEither.ok
+ *
+ * Créer un Right standardisé représentant une réussite sans valeur.
+ */
+import * as DEither from "@duplojs/lang/either";
+import type * as DCommon from "@duplojs/lang/common";
+
+const result = DEither.ok();
+
+// La sortie est `Ok`, un Right dont la valeur est `undefined`.
+type _CheckResult = DCommon.ExpectType<typeof result, DEither.Ok, "strict">;

package/docs/API/10-lang/10-either/10-result.ts

@@ -0,0 +1,18 @@
+/**
+ * @title DEither.result
+ *
+ * Créer un état contextualisé de type Result, sans lui attribuer un succès ou un échec.
+ */
+import * as DEither from "@duplojs/lang/either";
+import * as DCommon from "@duplojs/lang/common";
+
+// Appel classique : l’information et la valeur sont fournies ensemble.
+const direct = DEither.result("validated", 42);
+type _CheckDirect = DCommon.ExpectType<typeof direct, DEither.Result<"validated", 42>, "strict">;
+
+// Appel curifié : l’information est configurée avant la valeur dans le pipe.
+const piped = DCommon.pipe(
+	42,
+	DEither.result("validated"),
+);
+type _CheckPiped = DCommon.ExpectType<typeof piped, DEither.Result<"validated", 42>, "strict">;