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

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

@@ -0,0 +1,48 @@
+/**
+ * @title DGenerator.groupOutput
+ *
+ * Construire une sortie nommée destinée à la fonction de regroupement.
+ */
+import * as DCommon from "@duplojs/lang/common";
+import * as DGenerator from "@duplojs/lang/generator";
+import * as DPattern from "@duplojs/lang/pattern";
+import * as DString from "@duplojs/lang/string";
+
+declare const value: number;
+
+// Appel classique : associer directement la valeur au groupe `even`.
+const result = DGenerator.groupOutput("even", value);
+
+// La sortie associe le groupe `even` à la valeur fournie.
+type _CheckResult = DCommon.ExpectType<
+	typeof result,
+	DGenerator.GroupOutputResult<"even", number>,
+	"strict"
+>;
+
+// Composition dans un pipe : le pattern `when` sélectionne le premier groupe,
+// puis `otherwise` traite le reste sans ouvrir de callback intermédiaire.
+const input: string[] = ["a", "bb", "c"];
+
+const piped = DCommon.pipe(
+	input,
+	DGenerator.group(
+		DCommon.innerPipe(
+			DPattern.when(
+				DString.lengthEqual(1),
+				DGenerator.groupOutput("short"),
+			),
+			DPattern.otherwise(DGenerator.groupOutput("long")),
+		),
+	),
+);
+
+// La sortie vaut { short: ["a", "c"], long: ["bb"] }.
+type _CheckPiped = DCommon.ExpectType<
+	typeof piped,
+	{
+		readonly long?: readonly [string, ...string[]] | undefined;
+		readonly short?: readonly [string & DString.LengthEqual<1>, ...(string & DString.LengthEqual<1>)[]] | undefined;
+	},
+	"strict"
+>;

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

@@ -0,0 +1,46 @@
+/**
+ * @title DGenerator.loop
+ *
+ * Produire une séquence synchrone en distinguant les valeurs de `next` et celles de la sortie `exit`.
+ */
+import * as DArray from "@duplojs/lang/array";
+import * as DCommon from "@duplojs/lang/common";
+import * as DGenerator from "@duplojs/lang/generator";
+
+// `count` est le seul état fourni à chaque tour ; `next` émet des valeurs et continue.
+const withoutExitValue = DCommon.pipe(
+	DGenerator.loop(({ count, next, exit }: DGenerator.LoopParams<number>) => {
+		if (count === 3) {
+			return exit();
+		}
+
+		return next(count + 1);
+	}),
+	DArray.from,
+);
+
+// La sortie vaut [1, 2, 3] : `exit()` termine sans ajouter de valeur.
+type _CheckWithoutExitValue = DCommon.ExpectType<
+	typeof withoutExitValue,
+	readonly number[],
+	"strict"
+>;
+
+// `exit(value)` termine la boucle et émet sa valeur après celles émises par `next`.
+const withExitValue = DCommon.pipe(
+	DGenerator.loop(({ count, next, exit }: DGenerator.LoopParams<number>) => {
+		if (count === 3) {
+			return exit(4);
+		}
+
+		return next(count + 1);
+	}),
+	DArray.from,
+);
+
+// La sortie vaut [1, 2, 3, 4] : les valeurs multiples de `next` et `exit` forment la séquence.
+type _CheckWithExitValue = DCommon.ExpectType<
+	typeof withExitValue,
+	readonly number[],
+	"strict"
+>;

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

@@ -0,0 +1,33 @@
+/**
+ * @title DGenerator.loopAccumulator
+ *
+ * Produire une séquence synchrone en mettant à jour un accumulateur à chaque itération.
+ */
+import * as DArray from "@duplojs/lang/array";
+import type * as DCommon from "@duplojs/lang/common";
+import * as DGenerator from "@duplojs/lang/generator";
+
+const values = DArray.from(DGenerator.loopAccumulator(0, ({ accumulator, count, next, exit }) => count === 3
+	? exit(accumulator)
+	: next(accumulator + 1, accumulator)));
+
+// `next` reçoit d’abord le nouvel accumulateur, puis émet les valeurs suivantes.
+// La valeur de `exit` est également émise avant que le générateur se termine.
+type _CheckValues = DCommon.ExpectType<typeof values, readonly number[], "strict">;
+
+interface Accumulator {
+	readonly total: number;
+	readonly previous?: number;
+}
+
+const finalTotal = DArray.from(DGenerator.loopAccumulator(
+	DGenerator.loopAccumulatorFrom<Accumulator>({ total: 0 }),
+	({ accumulator, count, next, exit }) => count === 2
+		? exit(accumulator.total)
+		: next({
+			total: accumulator.total + 1,
+			previous: accumulator.total,
+		}, accumulator.total),
+));
+
+type _CheckFinalTotal = DCommon.ExpectType<typeof finalTotal, readonly number[], "strict">;

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

@@ -0,0 +1,30 @@
+/**
+ * @title DGenerator.loopAccumulatorFrom
+ *
+ * Marquer une valeur initiale pour fixer précisément le type de l’accumulateur d’une boucle.
+ */
+import type * as DCommon from "@duplojs/lang/common";
+import * as DGenerator from "@duplojs/lang/generator";
+
+interface Accumulator {
+	readonly total: number;
+	readonly previous?: number;
+}
+
+const initialAccumulator = DGenerator.loopAccumulatorFrom<Accumulator>({ total: 0 });
+
+type _CheckInitialAccumulator = DCommon.ExpectType<
+	typeof initialAccumulator,
+	DGenerator.LoopAccumulatorFromResult<Accumulator>,
+	"strict"
+>;
+
+const result = DGenerator.loopAccumulator(initialAccumulator, ({ accumulator, count, next, exit }) => count === 2
+	? exit(accumulator.total)
+	: next({
+		total: accumulator.total + 1,
+		previous: accumulator.total,
+	}, accumulator.total));
+
+// La boucle reçoit Accumulator comme état, tout en produisant sa valeur de sortie dans le générateur.
+type _CheckResult = DCommon.ExpectType<typeof result, Generator<number, unknown, unknown>, "strict">;

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

@@ -0,0 +1,35 @@
+/**
+ * @title DGenerator.map
+ *
+ * Transformer chaque valeur d’un itérable dans un générateur.
+ */
+import * as DCommon from "@duplojs/lang/common";
+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];
+
+// Appel classique : chaque nombre est doublé.
+const result = DGenerator.map(input, (item) => DNumber.sum([item, item]));
+
+// La sortie est un générateur qui produit [2, 4, 6].
+type _CheckResult = DCommon.ExpectType<
+	typeof result,
+	Generator<number, unknown, unknown>,
+	"strict"
+>;
+
+// Appel curifié : la transformation est configurée dans l’étape du pipe.
+const piped = DCommon.pipe(
+	input,
+	DGenerator.map((item) => DNumber.sum([item, item, item])),
+	DArray.from,
+);
+
+// La sortie vaut [3, 6, 9].
+type _CheckPiped = DCommon.ExpectType<
+	typeof piped,
+	readonly number[],
+	"strict"
+>;

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

@@ -0,0 +1,51 @@
+/**
+ * @title DGenerator.reduce
+ *
+ * Réduire un itérable avec un accumulateur et des sorties next ou exit.
+ */
+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];
+
+// Appel classique : le nombre initial est directement inféré comme accumulateur numérique.
+const result = DGenerator.reduce(
+	input,
+	0,
+	({ lastValue, item, next }) => next(DNumber.sum([lastValue, item])),
+);
+
+// La sortie vaut 6 et le type de l’accumulateur est inféré comme number.
+type _CheckResult = DCommon.ExpectType<typeof result, number, "strict">;
+
+type Accumulator =
+	| { total: number }
+	| { values: readonly number[] };
+
+// Appel curifié : le générique porté par reduceFrom décrit une union sans utiliser `as`.
+const piped = DCommon.pipe(
+	input,
+	DGenerator.reduce(
+		DGenerator.reduceFrom<Accumulator>({ total: 0 }),
+		({ lastValue, next }) => next(lastValue),
+	),
+);
+
+// La sortie conserve l’union { total: number } | { values: readonly number[] }.
+type _CheckPiped = DCommon.ExpectType<typeof piped, Accumulator, "strict">;
+
+// Une sortie exit interrompt la réduction : son type string est indépendant de l’accumulateur number.
+const stopped = DGenerator.reduce(
+	input,
+	0,
+	({ item, lastValue, next, exit }) => item === 2
+		? exit("stop")
+		: next(DNumber.sum([lastValue, item])),
+);
+
+type _CheckStopped = DCommon.ExpectType<
+	typeof stopped,
+	number | string,
+	"strict"
+>;

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

@@ -0,0 +1,30 @@
+/**
+ * @title DGenerator.reduceFrom
+ *
+ * Marquer une valeur initiale, éventuellement élargie par un générique, pour une réduction.
+ */
+import type * as DCommon from "@duplojs/lang/common";
+import * as DGenerator from "@duplojs/lang/generator";
+
+// Pour une valeur primitive, son type est inféré directement.
+const numberInitial = DGenerator.reduceFrom(0);
+
+type _CheckNumberInitial = DCommon.ExpectType<
+	typeof numberInitial,
+	DGenerator.ReduceFromResult<number>,
+	"strict"
+>;
+
+type Accumulator =
+	| { total: number }
+	| { values: readonly number[] };
+
+// Pour une structure plus large, le générique de reduceFrom fixe la shape ou l’union sans utiliser `as`.
+const result = DGenerator.reduce(
+	[1, 2, 3],
+	DGenerator.reduceFrom<Accumulator>({ total: 0 }),
+	({ lastValue, next }) => next(lastValue),
+);
+
+// La réduction désempaquette l’accumulateur et conserve l’union définie par reduceFrom.
+type _CheckResult = DCommon.ExpectType<typeof result, Accumulator, "strict">;

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

@@ -0,0 +1,96 @@
+## DGenerator
+
+Création et composition de génératrices synchrones ou asynchrones pour produire, transformer, filtrer, réduire et consommer des séquences de valeurs.
+
+### [DGenerator.asyncChunk](10-asyncChunk.ts)
+
+Regrouper les valeurs d’un itérable asynchrone en sous-itérables de taille bornée.
+ 
+### [DGenerator.asyncConcat](10-asyncConcat.ts)
+
+Enchaîner plusieurs itérables synchrones ou asynchrones dans un générateur asynchrone.
+ 
+### [DGenerator.asyncFilter](10-asyncFilter.ts)
+
+Conserver dans un générateur asynchrone les valeurs acceptées par un prédicat.
+ 
+### [DGenerator.asyncFlat](10-asyncFlat.ts)
+
+Aplatir récursivement les valeurs itérables d’un générateur asynchrone jusqu’à une profondeur donnée.
+ 
+### [DGenerator.asyncGroup](10-asyncGroup.ts)
+
+Regrouper les valeurs d’un itérable asynchrone selon les sorties nommées d’une callback.
+ 
+### [DGenerator.asyncLoop](10-asyncLoop.ts)
+
+Produire une séquence asynchrone en distinguant les valeurs de `next` et celles de la sortie `exit`.
+ 
+### [DGenerator.asyncLoopAccumulator](10-asyncLoopAccumulator.ts)
+
+Produire une séquence asynchrone en mettant à jour un accumulateur à chaque itération.
+ 
+### [DGenerator.asyncMap](10-asyncMap.ts)
+
+Transformer chaque valeur dans un générateur asynchrone, en autorisant une callback synchrone ou asynchrone.
+ 
+### [DGenerator.asyncReduce](10-asyncReduce.ts)
+
+Réduire un itérable avec un accumulateur et des sorties next ou exit dans une promesse.
+ 
+### [DGenerator.chunk](10-chunk.ts)
+
+Regrouper les valeurs d’un itérable en sous-itérables de taille bornée.
+ 
+### [DGenerator.concat](10-concat.ts)
+
+Enchaîner plusieurs itérables dans un générateur synchrone.
+ 
+### [DGenerator.createExternalAsyncGenerator](10-createExternalAsyncGenerator.ts)
+
+Créer un générateur asynchrone dont la prochaine valeur ou la fin sont déclenchées de l’extérieur.
+ 
+### [DGenerator.execute](10-execute.ts)
+
+Consommer une génératrice jusqu’à sa fin, en retournant une promesse pour les génératrices asynchrones.
+ 
+### [DGenerator.filter](10-filter.ts)
+
+Conserver dans un générateur les valeurs acceptées par un prédicat.
+ 
+### [DGenerator.flat](10-flat.ts)
+
+Aplatir récursivement les valeurs itérables jusqu’à une profondeur donnée.
+ 
+### [DGenerator.group](10-group.ts)
+
+Regrouper les valeurs d’un itérable selon les sorties nommées d’une callback.
+ 
+### [DGenerator.groupOutput](10-groupOutput.ts)
+
+Construire une sortie nommée destinée à la fonction de regroupement.
+ 
+### [DGenerator.loop](10-loop.ts)
+
+Produire une séquence synchrone en distinguant les valeurs de `next` et celles de la sortie `exit`.
+ 
+### [DGenerator.loopAccumulator](10-loopAccumulator.ts)
+
+Produire une séquence synchrone en mettant à jour un accumulateur à chaque itération.
+ 
+### [DGenerator.loopAccumulatorFrom](10-loopAccumulatorFrom.ts)
+
+Marquer une valeur initiale pour fixer précisément le type de l’accumulateur d’une boucle.
+ 
+### [DGenerator.map](10-map.ts)
+
+Transformer chaque valeur d’un itérable dans un générateur.
+ 
+### [DGenerator.reduce](10-reduce.ts)
+
+Réduire un itérable avec un accumulateur et des sorties next ou exit.
+ 
+### [DGenerator.reduceFrom](10-reduceFrom.ts)
+
+Marquer une valeur initiale, éventuellement élargie par un générique, pour une réduction.
+ 

package/docs/API/10-lang/10-generator/index.md

@@ -0,0 +1,3 @@
+## DGenerator
+
+Création et composition de génératrices synchrones ou asynchrones pour produire, transformer, filtrer, réduire et consommer des séquences de valeurs.

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">;

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

@@ -0,0 +1,35 @@
+/**
+ * @title DNumber.isMultipleOf
+ *
+ * Tester ou établir qu’un nombre est un multiple d’une valeur donnée.
+ */
+import * as DCommon from "@duplojs/lang/common";
+import * as DNumber from "@duplojs/lang/number";
+
+const result = DNumber.isMultipleOf(12, 3);
+// 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.isMultipleOf(value, 3)) {
+	type _CheckIfValue = DCommon.ExpectType<typeof value, number & DNumber.MultipleOf<3>, "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.isMultipleOf(3),
+		(value) => {
+			type _CheckValue = DCommon.ExpectType<typeof value, number & DNumber.MultipleOf<3>, "strict">;
+
+			return DNumber.sum([value]);
+		},
+	),
+);
+// La valeur est le nombre d’entrée lorsqu’il est multiple de 3.
+type _CheckTransformed = DCommon.ExpectType<typeof transformed, number, "strict">;

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

@@ -0,0 +1,33 @@
+/**
+ * @title DNumber.isNegative
+ *
+ * Vérifier qu’un nombre est négatif ou nul et établir cette contrainte.
+ */
+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 Negative.
+if (DNumber.isNegative(value)) {
+	type _CheckValue = DCommon.ExpectType<typeof value, number & DNumber.Negative, "strict">;
+}
+
+const result = DNumber.isNegative(0);
+// La valeur obtenue est true : zéro appartient à cette contrainte.
+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.isNegative,
+		(number) => {
+			type _CheckNumber = DCommon.ExpectType<typeof number, number & DNumber.Negative, "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">;