regenerate the Set\Call value each time a scenario is run

CHANGELOG.md

@@ -5,6 +5,7 @@
 ### Changed
 
 - When disabling memory limit it now longer tries to reset the memory limit to the previous value. (It seems PHP prevents setting the limit lower to the peak memory usage)
+- `Innmind\BlackBox\Set\Call` regenarate the value each time a scenario is run
 
 ### Fixed
 

proofs/set/call.php

@@ -22,15 +22,25 @@ static function($assert) {
         },
     )->tag(Tag::ci, Tag::local);
     yield test(
-        'Set\Call regenerate the value when shrinking',
+        'Set\Call is not shrinkable',
+        static function($assert) {
+            $set = Set\Call::of(static fn() => new \stdClass)->values(Random::default);
+            $current = $set->current();
+
+            $assert->false($current->shrinkable());
+        },
+    )->tag(Tag::ci, Tag::local);
+
+    yield test(
+        'Set\Call regenerate the value each time it is accessed',
         static function($assert) {
             $set = Set\Call::of(static fn() => new \stdClass)->values(Random::default);
             $current = $set->current();
 
             $assert
                 ->expected($current->unwrap())
                 ->not()
-                ->same($current->shrink()->a()->unwrap());
+                ->same($current->unwrap());
         },
     )->tag(Tag::ci, Tag::local);
 };

src/Set/Call.php

@@ -16,6 +16,10 @@ final class Call
      */
     public static function of(callable $call): Set
     {
-        return Integers::any()->map(static fn() => $call());
+        return FromGenerator::mutable(static function() use ($call) {
+            while (true) {
+                yield $call;
+            }
+        })->map(static fn($call) => $call());
     }
 }

src/Set/FromGenerator.php

@@ -24,6 +24,7 @@ final class FromGenerator implements Set
     private \Closure $generatorFactory;
     /** @var \Closure(T): bool */
     private \Closure $predicate;
+    private bool $immutable;
 
     /**
      * @psalm-mutation-free
@@ -36,10 +37,16 @@ private function __construct(
         callable $generatorFactory,
         int $size,
         \Closure $predicate,
+        bool $immutable,
     ) {
+        if (!$generatorFactory(Random::mersenneTwister) instanceof \Generator) {
+            throw new \TypeError('Argument 1 must be of type callable(): \Generator');
+        }
+
         $this->generatorFactory = \Closure::fromCallable($generatorFactory);
         $this->size = $size;
         $this->predicate = $predicate;
+        $this->immutable = $immutable;
     }
 
     /**
@@ -51,11 +58,19 @@ private function __construct(
      */
     public static function of(callable $generatorFactory): self
     {
-        if (!$generatorFactory(Random::mersenneTwister) instanceof \Generator) {
-            throw new \TypeError('Argument 1 must be of type callable(): \Generator');
-        }
+        return new self($generatorFactory, 100, static fn(): bool => true, true);
+    }
 
-        return new self($generatorFactory, 100, static fn(): bool => true);
+    /**
+     * @template V
+     *
+     * @param callable(Random): \Generator<V> $generatorFactory
+     *
+     * @return self<V>
+     */
+    public static function mutable(callable $generatorFactory): self
+    {
+        return new self($generatorFactory, 100, static fn(): bool => true, false);
     }
 
     /**
@@ -67,6 +82,7 @@ public function take(int $size): Set
             $this->generatorFactory,
             $size,
             $this->predicate,
+            $this->immutable,
         );
     }
 
@@ -90,6 +106,7 @@ static function(mixed $value) use ($previous, $predicate): bool {
 
                 return $predicate($value);
             },
+            $this->immutable,
         );
     }
 
@@ -98,7 +115,10 @@ static function(mixed $value) use ($previous, $predicate): bool {
      */
     public function map(callable $map): Set
     {
-        return Decorate::immutable($map, $this);
+        return match ($this->immutable) {
+            true => Decorate::immutable($map, $this),
+            false => Decorate::mutable($map, $this),
+        };
     }
 
     public function values(Random $random): \Generator
@@ -110,7 +130,10 @@ public function values(Random $random): \Generator
             $value = $generator->current();
 
             if (($this->predicate)($value)) {
-                yield Value::immutable($value);
+                yield match ($this->immutable) {
+                    true => Value::immutable($value),
+                    false => Value::mutable(static fn() => $value),
+                };
 
                 ++$iterations;
             }