@duplojs/agents-kit 0.1.0-beta.3 → 0.1.0-beta.6

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

@@ -6,12 +6,12 @@
 import * as DEither from "@duplojs/lang/either";
 import * as DCommon from "@duplojs/lang/common";
 
-const direct = DEither.unwrapOr(DEither.success("saved"), "fallback" as const);
+const direct = DEither.unwrapOr(DEither.success("saved"), "fallback");
 type _CheckDirect = DCommon.ExpectType<typeof direct, "saved" | "fallback", "strict">;
 
 const piped = DCommon.pipe(
 	DEither.left("missing"),
-	DEither.unwrapOr("fallback" as const),
+	DEither.unwrapOr("fallback"),
 );
 // Le Left prend la valeur de remplacement.
 type _CheckPiped = DCommon.ExpectType<typeof piped, "fallback", "strict">;

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

@@ -8,13 +8,13 @@ import * as DCommon from "@duplojs/lang/common";
 
 const direct = DEither.unwrapOtherwise(
 	DEither.left("missing"),
-	() => "fallback" as const,
+	() => "fallback",
 );
 type _CheckDirect = DCommon.ExpectType<typeof direct, "fallback", "strict">;
 
 const piped = DCommon.pipe(
 	DEither.success("saved"),
-	DEither.unwrapOtherwise(() => "fallback" as const),
+	DEither.unwrapOtherwise(() => "fallback"),
 );
 // La callback de remplacement n’est pas utilisée pour un Right.
 type _CheckPiped = DCommon.ExpectType<typeof piped, "saved" | "fallback", "strict">;

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

@@ -12,7 +12,7 @@ const input = DEither.left("invalid", "bad-input");
 const direct = DEither.whenHasInformation(
 	input,
 	"invalid",
-	(value) => `reason:${value}` as const,
+	(value) => `reason:${value}`,
 );
 type _CheckDirect = DCommon.ExpectType<typeof direct, "reason:bad-input", "strict">;
 
@@ -21,13 +21,14 @@ const piped = DCommon.pipe(
 	input,
 	DEither.whenHasInformation(
 		"invalid",
-		(value) => `reason:${value}` as const,
+		(value) => `reason:${value}`,
 	),
 );
 type _CheckPiped = DCommon.ExpectType<typeof piped, "reason:bad-input", "strict">;
 
+declare const mixedInput: DEither.Success<"saved"> | DEither.Left<"invalid", string>;
 const unchanged = DEither.whenHasInformation(
-	DEither.success("saved") as DEither.Success<"saved"> | DEither.Left<"invalid", string>,
+	mixedInput,
 	["invalid"],
 	(value) => value,
 );

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

@@ -6,24 +6,24 @@
 import * as DEither from "@duplojs/lang/either";
 import * as DCommon from "@duplojs/lang/common";
 
-const input = DEither.left("invalid", "bad-input") as DEither.Left<"invalid", string> | DEither.Success<"saved">;
+declare const input: DEither.Left<"invalid", string> | DEither.Success<"saved">;
 
 // Appel classique : la branche otherwise reçoit le résultat non ciblé.
 const direct = DEither.whenHasInformationOtherwise(
 	input,
 	"invalid",
-	(value) => `invalid:${value}` as const,
+	(value) => `invalid:${value}`,
 	(value) => DEither.unwrapRight(value),
 );
-type _CheckDirect = DCommon.ExpectType<typeof direct, "invalid:bad-input" | "saved", "one-extends-two">;
+type _CheckDirect = DCommon.ExpectType<typeof direct, `invalid:${string}` | "saved", "strict">;
 
 // Appel curifié : les deux traitements sont configurés dans le pipe.
 const piped = DCommon.pipe(
 	input,
 	DEither.whenHasInformationOtherwise(
 		"invalid",
-		(value) => `invalid:${value}` as const,
+		(value) => `invalid:${value}`,
 		(value) => DEither.unwrapRight(value),
 	),
 );
-type _CheckPiped = DCommon.ExpectType<typeof piped, "invalid:bad-input" | "saved", "one-extends-two">;
+type _CheckPiped = DCommon.ExpectType<typeof piped, `invalid:${string}` | "saved", "strict">;

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

@@ -9,12 +9,12 @@ import * as DCommon from "@duplojs/lang/common";
 const input = DEither.left("invalid", "bad-input");
 
 // Appel classique : la callback ne reçoit que la valeur du Left.
-const direct = DEither.whenIsLeft(input, (value) => `reason:${value}` as const);
+const direct = DEither.whenIsLeft(input, (value) => `reason:${value}`);
 type _CheckDirect = DCommon.ExpectType<typeof direct, "reason:bad-input", "strict">;
 
 // Appel curifié : la transformation est directement placée dans le pipe.
 const piped = DCommon.pipe(
 	input,
-	DEither.whenIsLeft((value) => `reason:${value}` as const),
+	DEither.whenIsLeft((value) => `reason:${value}`),
 );
 type _CheckPiped = DCommon.ExpectType<typeof piped, "reason:bad-input", "strict">;

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

@@ -6,22 +6,22 @@
 import * as DEither from "@duplojs/lang/either";
 import * as DCommon from "@duplojs/lang/common";
 
-const input = DEither.success("saved") as DEither.Success<"saved"> | DEither.Left<"invalid", string>;
+declare const input: DEither.Success<"saved"> | DEither.Left<"invalid", string>;
 
 // Appel classique : la seconde callback reçoit le résultat lorsqu’il n’est pas Left.
 const direct = DEither.whenIsLeftOtherwise(
 	input,
-	(value) => `left:${value}` as const,
+	(value) => `left:${value}`,
 	(value) => DEither.unwrapRight(value),
 );
-type _CheckDirect = DCommon.ExpectType<typeof direct, "left:invalid" | "saved", "one-extends-two">;
+type _CheckDirect = DCommon.ExpectType<typeof direct, `left:${string}` | "saved", "strict">;
 
 // Appel curifié : les deux branches sont configurées avant l’entrée du pipe.
 const piped = DCommon.pipe(
 	input,
 	DEither.whenIsLeftOtherwise(
-		(value) => `left:${value}` as const,
+		(value) => `left:${value}`,
 		(value) => DEither.unwrapRight(value),
 	),
 );
-type _CheckPiped = DCommon.ExpectType<typeof piped, "left:invalid" | "saved", "one-extends-two">;
+type _CheckPiped = DCommon.ExpectType<typeof piped, `left:${string}` | "saved", "strict">;

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

@@ -9,12 +9,12 @@ import * as DCommon from "@duplojs/lang/common";
 const input = DEither.success("saved");
 
 // Appel classique : la callback ne reçoit que la valeur du Right.
-const direct = DEither.whenIsRight(input, (value) => `status:${value}` as const);
+const direct = DEither.whenIsRight(input, (value) => `status:${value}`);
 type _CheckDirect = DCommon.ExpectType<typeof direct, "status:saved", "strict">;
 
 // Appel curifié : la transformation est directement placée dans le pipe.
 const piped = DCommon.pipe(
 	input,
-	DEither.whenIsRight((value) => `status:${value}` as const),
+	DEither.whenIsRight((value) => `status:${value}`),
 );
 type _CheckPiped = DCommon.ExpectType<typeof piped, "status:saved", "strict">;

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

@@ -6,21 +6,21 @@
 import * as DEither from "@duplojs/lang/either";
 import * as DCommon from "@duplojs/lang/common";
 
-const input = DEither.success("saved") as DEither.Success<"saved"> | DEither.Left<"missing", string>;
+declare const input: DEither.Success<"saved"> | DEither.Left<"missing", string>;
 
 const direct = DEither.whenIsRightOtherwise(
 	input,
-	(value) => `right:${value}` as const,
-	(value) => `left:${DEither.unwrapLeft(value)}` as const,
+	(value) => `right:${value}`,
+	(value) => `left:${DEither.unwrapLeft(value)}`,
 );
-type _CheckDirect = DCommon.ExpectType<typeof direct, "right:saved" | "left:missing", "one-extends-two">;
+type _CheckDirect = DCommon.ExpectType<typeof direct, "right:saved" | `left:${string}`, "strict">;
 
 // Appel curifié : les deux branches sont configurées avant l’entrée du pipe.
 const piped = DCommon.pipe(
 	input,
 	DEither.whenIsRightOtherwise(
-		(value) => `right:${value}` as const,
-		(value) => `left:${DEither.unwrapLeft(value)}` as const,
+		(value) => `right:${value}`,
+		(value) => `left:${DEither.unwrapLeft(value)}`,
 	),
 );
-type _CheckPiped = DCommon.ExpectType<typeof piped, "right:saved" | "left:missing", "one-extends-two">;
+type _CheckPiped = DCommon.ExpectType<typeof piped, "right:saved" | `left:${string}`, "strict">;

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

@@ -6,7 +6,7 @@
 import * as DEither from "@duplojs/lang/either";
 import * as DCommon from "@duplojs/lang/common";
 
-const input = DEither.left("invalid", "bad-input") as DEither.Left<"invalid", string> | DEither.Success<"saved">;
+declare const input: DEither.Left<"invalid", string> | DEither.Success<"saved">;
 
 // Appel classique : seule la variante invalid est transformée.
 const direct = DEither.whenIsSelected(
@@ -15,9 +15,9 @@ const direct = DEither.whenIsSelected(
 		invalid: true,
 		success: false,
 	},
-	(value) => `invalid:${value}` as const,
+	(value) => `invalid:${value}`,
 );
-type _CheckDirect = DCommon.ExpectType<typeof direct, "invalid:bad-input" | DEither.Success<"saved">, "one-extends-two">;
+type _CheckDirect = DCommon.ExpectType<typeof direct, `invalid:${string}` | DEither.Success<"saved">, "strict">;
 
 // Appel curifié : la sélection et la callback sont configurées dans le pipe.
 const piped = DCommon.pipe(
@@ -27,7 +27,7 @@ const piped = DCommon.pipe(
 			invalid: true,
 			success: false,
 		},
-		(value) => `invalid:${value}` as const,
+		(value) => `invalid:${value}`,
 	),
 );
-type _CheckPiped = DCommon.ExpectType<typeof piped, "invalid:bad-input" | DEither.Success<"saved">, "one-extends-two">;
+type _CheckPiped = DCommon.ExpectType<typeof piped, `invalid:${string}` | DEither.Success<"saved">, "strict">;

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

@@ -6,7 +6,7 @@
 import * as DEither from "@duplojs/lang/either";
 import * as DCommon from "@duplojs/lang/common";
 
-const input = DEither.left("invalid", "bad-input") as DEither.Left<"invalid", string> | DEither.Success<"saved">;
+declare const input: DEither.Left<"invalid", string> | DEither.Success<"saved">;
 
 // Appel classique : la branche otherwise reçoit le Right non sélectionné.
 const direct = DEither.whenIsSelectedOtherwise(
@@ -15,10 +15,10 @@ const direct = DEither.whenIsSelectedOtherwise(
 		invalid: true,
 		success: false,
 	},
-	(value) => `invalid:${value}` as const,
+	(value) => `invalid:${value}`,
 	(value) => DEither.unwrapRight(value),
 );
-type _CheckDirect = DCommon.ExpectType<typeof direct, "invalid:bad-input" | "saved", "one-extends-two">;
+type _CheckDirect = DCommon.ExpectType<typeof direct, `invalid:${string}` | "saved", "strict">;
 
 // Appel curifié : la sélection et les deux callbacks sont configurées dans le pipe.
 const piped = DCommon.pipe(
@@ -28,8 +28,8 @@ const piped = DCommon.pipe(
 			invalid: true,
 			success: false,
 		},
-		(value) => `invalid:${value}` as const,
+		(value) => `invalid:${value}`,
 		(value) => DEither.unwrapRight(value),
 	),
 );
-type _CheckPiped = DCommon.ExpectType<typeof piped, "invalid:bad-input" | "saved", "one-extends-two">;
+type _CheckPiped = DCommon.ExpectType<typeof piped, `invalid:${string}` | "saved", "strict">;

package/docs/API/10-lang/10-either/index.llms.md

@@ -18,6 +18,10 @@ Créer un Left standardisé avec l’information `error`.
 
 Retourner un Either sans modifier sa valeur ni son type.
  
+### [DEither.extractErrorInLeft](10-extractErrorInLeft.ts)
+
+Extraire d’un Left les erreurs DuploJS sélectionnées par leur identifiant.
+ 
 ### [DEither.fail](10-fail.ts)
 
 Créer un Left standardisé représentant un échec sans valeur.
@@ -62,6 +66,14 @@ Créer un résultat Left avec une information et une valeur optionnelle.
 
 Appliquer exhaustivement une callback selon l’information du résultat.
  
+### [DEither.matchInformationCombination](10-matchInformationCombination.ts)
+
+Appliquer un traitement pour chaque combinaison d’informations d’une collection d’Either.
+ 
+### [DEither.matchInformationCombinationOtherwise](10-matchInformationCombinationOtherwise.ts)
+
+Traiter les combinaisons d’informations choisies et fournir un cas de repli.
+ 
 ### [DEither.matchInformationOtherwise](10-matchInformationOtherwise.ts)
 
 Appliquer une callback pour certaines informations et une branche de repli pour les autres.

package/docs/API/10-lang/10-generator/10-asyncConcat.ts

@@ -9,18 +9,18 @@ import * as DGenerator from "@duplojs/lang/generator";
 
 const head = (async function *() {
 	await DCommon.timeout();
-	yield 1 as const;
-	yield 2 as const;
+	yield 1;
+	yield 2;
 })();
 
 const tail = (async function *() {
 	await DCommon.timeout();
-	yield 4 as const;
-	yield 5 as const;
+	yield 4;
+	yield 5;
 })();
 
 // Appel classique : les valeurs sont produites dans l’ordre [1, 2, 3, 4, 5].
-const result = DGenerator.asyncConcat(head, [3] as const, tail);
+const result = DGenerator.asyncConcat(head, [3], tail);
 
 type _CheckResult = DCommon.ExpectType<
 	typeof result,
@@ -31,16 +31,13 @@ type _CheckResult = DCommon.ExpectType<
 // Appel curifié : les itérables ajoutés sont configurés dans l’étape du pipe.
 const piped = DCommon.pipe(
 	[1, 2],
-	DGenerator.asyncConcat(([
-		3,
-		4,
-	] as number[])),
+	DGenerator.asyncConcat([3, 4]),
 	DArray.from,
 );
 
 // La promesse se résout vers [1, 2, 3, 4].
 type _CheckPiped = DCommon.ExpectType<
 	typeof piped,
-	Promise<readonly number[]>,
+	Promise<readonly (1 | 2 | 3 | 4)[]>,
 	"strict"
 >;

package/docs/API/10-lang/10-generator/10-asyncFlat.ts

@@ -8,8 +8,8 @@ import * as DGenerator from "@duplojs/lang/generator";
 
 const input = (async function *() {
 	await DCommon.timeout();
-	yield [[1], [2]] as const;
-	yield [[3]] as const;
+	yield [[1], [2]];
+	yield [[3]];
 })();
 
 // Profondeur par défaut : un seul niveau est aplati, donc la sortie contient [[1], [2], [3]].
@@ -17,14 +17,14 @@ const result = DGenerator.asyncFlat(input);
 
 type _CheckResult = DCommon.ExpectType<
 	typeof result,
-	AsyncGenerator<readonly [1] | readonly [2] | readonly [3], void, unknown>,
+	AsyncGenerator<number[], void, unknown>,
 	"strict"
 >;
 
 const nestedInput = (async function *() {
 	await DCommon.timeout();
-	yield [[1], [2]] as const;
-	yield [[3]] as const;
+	yield [[1], [2]];
+	yield [[3]];
 })();
 
 // Une profondeur de deux aplati également les tuples internes : la sortie contient [1, 2, 3].
@@ -32,6 +32,6 @@ const deeplyFlattened = DGenerator.asyncFlat(nestedInput, 2);
 
 type _CheckDeeplyFlattened = DCommon.ExpectType<
 	typeof deeplyFlattened,
-	AsyncGenerator<1 | 2 | 3, void, unknown>,
+	AsyncGenerator<number, void, unknown>,
 	"strict"
 >;

package/docs/API/10-lang/10-generator/10-concat.ts

@@ -9,9 +9,9 @@ import * as DGenerator from "@duplojs/lang/generator";
 
 // Appel classique : les valeurs sont produites dans l’ordre [1, 2, 3, 4].
 const result = DGenerator.concat(
-	[1, 2] as const,
-	[3] as const,
-	[4] as const,
+	[1, 2],
+	[3],
+	[4],
 );
 
 type _CheckResult = DCommon.ExpectType<

package/docs/API/10-lang/10-generator/10-flat.ts

@@ -7,7 +7,7 @@ import type * as DCommon from "@duplojs/lang/common";
 import * as DGenerator from "@duplojs/lang/generator";
 
 // Profondeur par défaut : un seul niveau est aplati et la sortie contient [1, 2, 3].
-const result = DGenerator.flat([[1, 2], [3]] as const);
+const result = DGenerator.flat([[1, 2], [3]]);
 
 type _CheckResult = DCommon.ExpectType<
 	typeof result,
@@ -16,7 +16,7 @@ type _CheckResult = DCommon.ExpectType<
 >;
 
 // Une profondeur de deux aplati deux niveaux et produit également [1, 2, 3].
-const deeplyFlattened = DGenerator.flat([[[1], [2]], [[3]]] as const, 2);
+const deeplyFlattened = DGenerator.flat([[[1], [2]], [[3]]], 2);
 
 type _CheckDeeplyFlattened = DCommon.ExpectType<
 	typeof deeplyFlattened,

package/docs/API/10-lang/10-generator/10-map.ts

@@ -8,7 +8,7 @@ import * as DArray from "@duplojs/lang/array";
 import * as DGenerator from "@duplojs/lang/generator";
 import * as DNumber from "@duplojs/lang/number";
 
-const input = [1, 2, 3] as const;
+const input = [1, 2, 3];
 
 // Appel classique : chaque nombre est doublé.
 const result = DGenerator.map(input, (item) => DNumber.sum([item, item]));

package/docs/API/10-lang/10-generator/10-reduce.ts

@@ -7,7 +7,7 @@ import * as DCommon from "@duplojs/lang/common";
 import * as DGenerator from "@duplojs/lang/generator";
 import * as DNumber from "@duplojs/lang/number";
 
-const input = [1, 2, 3] as const;
+const input = [1, 2, 3];
 
 // Appel classique : le nombre initial est directement inféré comme accumulateur numérique.
 const result = DGenerator.reduce(

package/docs/API/10-lang/10-number/10-betweenThan.ts

@@ -0,0 +1,43 @@
+/**
+ * @title DNumber.betweenThan
+ *
+ * Vérifier qu’un nombre est strictement compris entre deux bornes.
+ */
+import * as DCommon from "@duplojs/lang/common";
+import * as DNumber from "@duplojs/lang/number";
+
+const result = DNumber.betweenThan(5, 1, 10);
+// Appel classique : tester directement une valeur.
+// La valeur obtenue est true, car 5 est strictement entre 1 et 10.
+type _CheckResult = DCommon.ExpectType<typeof result, boolean, "strict">;
+
+declare const value: number;
+
+if (DNumber.betweenThan(value, 1, 10)) {
+	type _CheckIfValue = DCommon.ExpectType<
+		typeof value,
+		number & DNumber.GreaterThan<1> & DNumber.LessThan<10>,
+		"strict"
+	>;
+	const sum = DNumber.sum([value]);
+	type _CheckSum = DCommon.ExpectType<typeof sum, number, "strict">;
+}
+
+// Appel curifié : passer le predicate directement à DCommon.when.
+const transformed = DCommon.pipe(
+	value,
+	DCommon.when(
+		DNumber.betweenThan(1, 10),
+		(value) => {
+			type _CheckValue = DCommon.ExpectType<
+				typeof value,
+				number & DNumber.GreaterThan<1> & DNumber.LessThan<10>,
+				"strict"
+			>;
+
+			return DNumber.sum([value]);
+		},
+	),
+);
+// La valeur est le nombre d’entrée lorsqu’il satisfait l’intervalle.
+type _CheckTransformed = DCommon.ExpectType<typeof transformed, number, "strict">;

package/docs/API/10-lang/10-number/10-betweenThanOrEqual.ts

@@ -0,0 +1,43 @@
+/**
+ * @title DNumber.betweenThanOrEqual
+ *
+ * Vérifier qu’un nombre appartient à un intervalle fermé.
+ */
+import * as DCommon from "@duplojs/lang/common";
+import * as DNumber from "@duplojs/lang/number";
+
+const result = DNumber.betweenThanOrEqual(5, 5, 10);
+// Appel classique : tester directement une valeur.
+// La valeur obtenue est true, car les bornes sont inclusives.
+type _CheckResult = DCommon.ExpectType<typeof result, boolean, "strict">;
+
+declare const value: number;
+
+if (DNumber.betweenThanOrEqual(value, 5, 10)) {
+	type _CheckIfValue = DCommon.ExpectType<
+		typeof value,
+		number & DNumber.GreaterThanOrEqual<5> & DNumber.LessThanOrEqual<10>,
+		"strict"
+	>;
+	const sum = DNumber.sum([value]);
+	type _CheckSum = DCommon.ExpectType<typeof sum, number, "strict">;
+}
+
+// Appel curifié : passer le predicate directement à DCommon.when.
+const transformed = DCommon.pipe(
+	value,
+	DCommon.when(
+		DNumber.betweenThanOrEqual(5, 10),
+		(value) => {
+			type _CheckValue = DCommon.ExpectType<
+				typeof value,
+				number & DNumber.GreaterThanOrEqual<5> & DNumber.LessThanOrEqual<10>,
+				"strict"
+			>;
+
+			return DNumber.sum([value]);
+		},
+	),
+);
+// La valeur est le nombre d’entrée lorsqu’il satisfait l’intervalle.
+type _CheckTransformed = DCommon.ExpectType<typeof transformed, number, "strict">;

package/docs/API/10-lang/10-number/10-greaterThan.ts

@@ -0,0 +1,35 @@
+/**
+ * @title DNumber.greaterThan
+ *
+ * Tester ou établir qu’un nombre est strictement supérieur à une borne.
+ */
+import * as DCommon from "@duplojs/lang/common";
+import * as DNumber from "@duplojs/lang/number";
+
+const result = DNumber.greaterThan(8, 5);
+// Appel classique : tester directement une valeur.
+// La valeur obtenue est true.
+type _CheckResult = DCommon.ExpectType<typeof result, boolean, "strict">;
+
+declare const value: number;
+
+if (DNumber.greaterThan(value, 5)) {
+	type _CheckIfValue = DCommon.ExpectType<typeof value, number & DNumber.GreaterThan<5>, "strict">;
+	const sum = DNumber.sum([value]);
+	type _CheckSum = DCommon.ExpectType<typeof sum, number, "strict">;
+}
+
+// Appel curifié : passer le predicate directement à DCommon.when.
+const transformed = DCommon.pipe(
+	value,
+	DCommon.when(
+		DNumber.greaterThan(5),
+		(value) => {
+			type _CheckValue = DCommon.ExpectType<typeof value, number & DNumber.GreaterThan<5>, "strict">;
+
+			return DNumber.sum([value]);
+		},
+	),
+);
+// La valeur est le nombre d’entrée lorsqu’il est supérieur à 5.
+type _CheckTransformed = DCommon.ExpectType<typeof transformed, number, "strict">;

package/docs/API/10-lang/10-number/10-greaterThanOrEqual.ts

@@ -0,0 +1,35 @@
+/**
+ * @title DNumber.greaterThanOrEqual
+ *
+ * Tester ou établir qu’un nombre est supérieur ou égal à une borne.
+ */
+import * as DCommon from "@duplojs/lang/common";
+import * as DNumber from "@duplojs/lang/number";
+
+const result = DNumber.greaterThanOrEqual(5, 5);
+// Appel classique : tester directement une valeur.
+// La valeur obtenue est true, car l’égalité est acceptée.
+type _CheckResult = DCommon.ExpectType<typeof result, boolean, "strict">;
+
+declare const value: number;
+
+if (DNumber.greaterThanOrEqual(value, 5)) {
+	type _CheckIfValue = DCommon.ExpectType<typeof value, number & DNumber.GreaterThanOrEqual<5>, "strict">;
+	const sum = DNumber.sum([value]);
+	type _CheckSum = DCommon.ExpectType<typeof sum, number, "strict">;
+}
+
+// Appel curifié : passer le predicate directement à DCommon.when.
+const transformed = DCommon.pipe(
+	value,
+	DCommon.when(
+		DNumber.greaterThanOrEqual(5),
+		(value) => {
+			type _CheckValue = DCommon.ExpectType<typeof value, number & DNumber.GreaterThanOrEqual<5>, "strict">;
+
+			return DNumber.sum([value]);
+		},
+	),
+);
+// La valeur est le nombre d’entrée lorsqu’il est supérieur ou égal à 5.
+type _CheckTransformed = DCommon.ExpectType<typeof transformed, number, "strict">;

package/docs/API/10-lang/10-number/10-isEven.ts

@@ -0,0 +1,33 @@
+/**
+ * @title DNumber.isEven
+ *
+ * Vérifier qu’un nombre est pair et établir cette contrainte dans le type.
+ */
+import * as DCommon from "@duplojs/lang/common";
+import * as DNumber from "@duplojs/lang/number";
+
+declare const value: number;
+
+// Appel classique : le test réussi affine la valeur avec la contrainte Even.
+if (DNumber.isEven(value)) {
+	type _CheckValue = DCommon.ExpectType<typeof value, number & DNumber.Even, "strict">;
+}
+
+const result = DNumber.isEven(4);
+// La valeur obtenue est true.
+type _CheckResult = DCommon.ExpectType<typeof result, boolean, "strict">;
+
+// Le même predicate peut servir d’étape unaire dans un pipe.
+const sum = DCommon.pipe(
+	value,
+	DCommon.when(
+		DNumber.isEven,
+		(number) => {
+			type _CheckNumber = DCommon.ExpectType<typeof number, number & DNumber.Even, "strict">;
+
+			return DNumber.sum([number]);
+		},
+	),
+);
+// La contrainte a servi à accepter l’entrée ; la somme n’en porte pas la preuve.
+type _CheckSum = DCommon.ExpectType<typeof sum, number, "strict">;

package/docs/API/10-lang/10-number/10-isInteger.ts

@@ -0,0 +1,33 @@
+/**
+ * @title DNumber.isInteger
+ *
+ * Vérifier qu’un nombre est entier et établir cette contrainte dans le type.
+ */
+import * as DCommon from "@duplojs/lang/common";
+import * as DNumber from "@duplojs/lang/number";
+
+declare const value: number;
+
+// Appel classique : le test réussi affine la valeur avec la contrainte Integer.
+if (DNumber.isInteger(value)) {
+	type _CheckValue = DCommon.ExpectType<typeof value, number & DNumber.Integer, "strict">;
+}
+
+const result = DNumber.isInteger(4);
+// La valeur obtenue est true.
+type _CheckResult = DCommon.ExpectType<typeof result, boolean, "strict">;
+
+// Le même predicate peut servir d’étape unaire dans un pipe.
+const sum = DCommon.pipe(
+	value,
+	DCommon.when(
+		DNumber.isInteger,
+		(number) => {
+			type _CheckNumber = DCommon.ExpectType<typeof number, number & DNumber.Integer, "strict">;
+
+			return DNumber.sum([number]);
+		},
+	),
+);
+// La contrainte a servi à accepter l’entrée ; la somme n’en porte pas la preuve.
+type _CheckSum = DCommon.ExpectType<typeof sum, number, "strict">;