split of implementation from constructor

Author: Baptouuuu

src/Constraint.php

@@ -48,7 +48,7 @@ public function __invoke(mixed $input): Validation
      */
     public static function of(callable $assert): self
     {
-        return new self(Of::callable($assert));
+        return new self(Constraint\Of::callable($assert));
     }
 
     /**

src/Constraint/Of.php

@@ -0,0 +1,49 @@
+<?php
+declare(strict_types = 1);
+
+namespace Innmind\Validation\Constraint;
+
+use Innmind\Validation\Failure;
+use Innmind\Immutable\Validation;
+
+/**
+ * @internal
+ * @template-covariant A
+ * @template-covariant B
+ * @implements Implementation<A, B>
+ * @psalm-immutable
+ */
+final class Of implements Implementation
+{
+    /** @var pure-callable(A): Validation<Failure, B> */
+    private $assert;
+
+    /**
+     * @param pure-callable(A): Validation<Failure, B> $assert
+     */
+    private function __construct(callable $assert)
+    {
+        $this->assert = $assert;
+    }
+
+    #[\Override]
+    public function __invoke(mixed $value): Validation
+    {
+        return ($this->assert)($value);
+    }
+
+    /**
+     * @internal
+     * @template T
+     * @template U
+     * @psalm-pure
+     *
+     * @param pure-callable(T): Validation<Failure, U> $assert
+     *
+     * @return self<T, U>
+     */
+    public static function callable(callable $assert): self
+    {
+        return new self($assert);
+    }
+}

src/Is.php

@@ -187,12 +187,12 @@ public static function associativeArray(
      *
      * @param ?non-empty-string $message
      *
-     * @return Implementation<Maybe<V>, V>
+     * @return Constraint<Maybe<V>, V>
      */
-    public static function just(?string $message = null): Implementation
+    public static function just(?string $message = null): Constraint
     {
         /** @psalm-suppress MixedArgumentTypeCoercion */
-        return Of::callable(static fn(Maybe $value) => $value->match(
+        return Constraint::of(static fn(Maybe $value) => $value->match(
             Validation::success(...),
             static fn() => Validation::fail(Failure::of(
                 $message ?? 'No value was provided',
@@ -207,11 +207,11 @@ public static function just(?string $message = null): Implementation
      * @param V $value
      * @param ?non-empty-string $message
      *
-     * @return Implementation<mixed, V>
+     * @return Constraint<mixed, V>
      */
-    public static function value(mixed $value, ?string $message = null): Implementation
+    public static function value(mixed $value, ?string $message = null): Constraint
     {
-        return Of::callable(static fn(mixed $in) => match ($in) {
+        return Constraint::of(static fn(mixed $in) => match ($in) {
             $value => Validation::success($value),
             default => Validation::fail(Failure::of(
                 $message ?? \sprintf(

src/Of.php

@@ -6,35 +6,12 @@
 use Innmind\Immutable\Validation;
 
 /**
- * @template-covariant A
- * @template-covariant B
- * @implements Constraint\Implementation<A, B>
- * @implements Constraint\Provider<A, B>
  * @psalm-immutable
  */
-final class Of implements Constraint\Implementation, Constraint\Provider
+final class Of
 {
-    /** @var pure-callable(A): Validation<Failure, B> */
-    private $assert;
-
-    /**
-     * @param pure-callable(A): Validation<Failure, B> $assert
-     */
-    private function __construct(callable $assert)
-    {
-        $this->assert = $assert;
-    }
-
-    #[\Override]
-    public function __invoke(mixed $value): Validation
-    {
-        return ($this->assert)($value);
-    }
-
-    #[\Override]
-    public function toConstraint(): Constraint
+    private function __construct()
     {
-        return Constraint::build($this);
     }
 
     /**
@@ -44,10 +21,10 @@ public function toConstraint(): Constraint
      *
      * @param pure-callable(T): Validation<Failure, U> $assert
      *
-     * @return self<T, U>
+     * @return Constraint<T, U>
      */
-    public static function callable(callable $assert): self
+    public static function callable(callable $assert): Constraint
     {
-        return new self($assert);
+        return Constraint::of($assert);
     }
 }