Allow to map failures

CHANGELOG.md

@@ -6,6 +6,7 @@
 
 - `Innmind\Validation\Failure::tag()`
 - `Innmind\Validation\Failure::tags()`
+- `Innmind\Validation\Constraint::mapFailures()`
 
 ## 2.2.0 - 2025-09-04
 

proofs/constraint.php

@@ -60,4 +60,41 @@ static function($assert, $in, $out, $message) {
             );
         },
     );
+
+    yield proof(
+        'Constraint::mapFailures()',
+        given(
+            Set::type(),
+            Set::strings(),
+            Set::strings(),
+        ),
+        static function($assert, $value, $message, $path) {
+            $success = Validation::success(...);
+            $fail = static fn() => Validation::fail(Failure::of($message));
+
+            $assert->same(
+                $value,
+                Constraint::of($success)
+                    ->mapFailures(static fn($failure) => $failure->under($path))($value)
+                    ->match(
+                        static fn($value) => $value,
+                        static fn() => null,
+                    ),
+            );
+            $assert->same(
+                [[$path, $message]],
+                Constraint::of($fail)
+                    ->mapFailures(static fn($failure) => $failure->under($path))($value)
+                    ->match(
+                        static fn() => null,
+                        static fn($failures) => $failures
+                            ->map(static fn($failure) => [
+                                $failure->path()->toString(),
+                                $failure->message(),
+                            ])
+                            ->toList(),
+                    ),
+            );
+        },
+    );
 };

src/Constraint.php

@@ -264,6 +264,20 @@ public function withFailure(string $message): self
         return $this->failWith($message);
     }
 
+    /**
+     * @param callable(Failure): Failure $map
+     *
+     * @return self<I, O>
+     */
+    #[\NoDiscard]
+    public function mapFailures(callable $map): self
+    {
+        return new self(Constraint\MapFailures::of(
+            $this->implementation,
+            $map,
+        ));
+    }
+
     /**
      * @return Predicate<O>
      */

src/Constraint/MapFailures.php

@@ -0,0 +1,50 @@
+<?php
+declare(strict_types = 1);
+
+namespace Innmind\Validation\Constraint;
+
+use Innmind\Validation\Failure;
+use Innmind\Immutable\Validation;
+
+/**
+ * @internal
+ * @template-covariant I
+ * @template-covariant O
+ * @implements Implementation<I, O>
+ * @psalm-immutable
+ */
+final class MapFailures implements Implementation
+{
+    /**
+     * @param Implementation<I, O> $constraint
+     * @param \Closure(Failure): Failure $map
+     */
+    private function __construct(
+        private Implementation $constraint,
+        private \Closure $map,
+    ) {
+    }
+
+    #[\Override]
+    public function __invoke(mixed $value): Validation
+    {
+        /** @psalm-suppress ImpureFunctionCall */
+        return ($this->constraint)($value)->mapFailures($this->map);
+    }
+
+    /**
+     * @internal
+     * @template A
+     * @template B
+     * @psalm-pure
+     *
+     * @param Implementation<A, B> $constraint
+     * @param callable(Failure): Failure $map
+     *
+     * @return self<A, B>
+     */
+    public static function of(Implementation $constraint, callable $map): self
+    {
+        return new self($constraint, \Closure::fromCallable($map));
+    }
+}