remove warnings

Author: Baptouuuu

proofs/attempt.php

@@ -301,7 +301,7 @@ static function($assert, $result, $e) {
                         static fn() => null,
                     ),
             );
-            $attempt->memoize();
+            $_ = $attempt->memoize();
             $assert->same(1, $called);
 
             $called = 0;
@@ -321,7 +321,7 @@ static function($assert, $result, $e) {
                         static fn($value) => $value,
                     ),
             );
-            $attempt->memoize();
+            $_ = $attempt->memoize();
             $assert->same(1, $called);
         },
     );
@@ -346,12 +346,12 @@ static function($assert, $result1, $result2, $e1, $e2) {
                 ->recover(static fn() => Attempt::error($e2));
 
             $assert->false($loaded);
-            $attempt->maybe();
+            $_ = $attempt->maybe();
             $assert->false($loaded);
-            $attempt->either();
+            $_ = $attempt->either();
             $assert->false($loaded);
 
-            $attempt->memoize();
+            $_ = $attempt->memoize();
             $assert->true($loaded);
 
             $assert->same(

proofs/either.php

@@ -20,7 +20,7 @@ static function($assert, $value) {
                 });
 
             $assert->false($loaded);
-            $either->memoize();
+            $_ = $either->memoize();
             $assert->true($loaded);
         },
     );

proofs/maybe.php

@@ -59,7 +59,7 @@ static function($assert, $value) {
                 });
 
             $assert->false($loaded);
-            $maybe->memoize();
+            $_ = $maybe->memoize();
             $assert->true($loaded);
         },
     );

proofs/sequence.php

@@ -78,12 +78,12 @@ static function($assert, $string, $chunk) {
                 ->split()
                 ->chunk($chunk);
 
-            $chunks->foreach(
+            $_ = $chunks->foreach(
                 static fn($chars) => $assert
                     ->number($chars->size())
                     ->lessThanOrEqual($chunk),
             );
-            $chunks
+            $_ = $chunks
                 ->dropEnd(1)
                 ->foreach(
                     static fn($chars) => $assert->same(
@@ -160,7 +160,7 @@ static function($assert, $calls) {
             }
 
             try {
-                $sequence->toList();
+                $_ = $sequence->toList();
                 $assert->fail('it should throw');
             } catch (Exception $e) {
                 $assert->same($expected, $e);

properties/Sequence/Windows.php

@@ -36,7 +36,7 @@ public function applicableTo(object $systemUnderTest): bool
 
     public function ensureHeldBy(Assert $assert, object $systemUnderTest): object
     {
-        $systemUnderTest
+        $_ = $systemUnderTest
             ->windows($this->size)
             ->foreach(
                 fn($window) => $assert
@@ -46,7 +46,7 @@ public function ensureHeldBy(Assert $assert, object $systemUnderTest): object
             );
 
         if ($systemUnderTest->size() >= $this->size) {
-            $systemUnderTest
+            $_ = $systemUnderTest
                 ->windows($this->size)
                 ->foreach(fn($window) => $assert->same(
                     $this->size,

tests/MapTest.php

@@ -187,7 +187,7 @@ public function testForeach()
             ->put(3, 4);
         $count = 0;
 
-        $m->foreach(function(int $key, int $value) use (&$count) {
+        $_ = $m->foreach(function(int $key, int $value) use (&$count) {
             $this->assertSame($count, $key);
             $this->assertSame($value, $key + 1);
             ++$count;

tests/MaybeTest.php

@@ -430,7 +430,7 @@ public function testAllMapNotCalledWhenOneNothingIsPresent(): BlackBox\Proof
 
                 $this->assertInstanceOf(Maybe\Comprehension::class, $comprehension);
                 $called = false;
-                $comprehension->map(static function(...$args) use (&$called) {
+                $_ = $comprehension->map(static function(...$args) use (&$called) {
                     $called = true;
 
                     return $args[0];
@@ -453,7 +453,7 @@ public function testAllFlatMapNotCalledWhenOneNothingIsPresent(): BlackBox\Proof
 
                 $this->assertInstanceOf(Maybe\Comprehension::class, $comprehension);
                 $called = false;
-                $comprehension->flatMap(static function(...$args) use (&$called) {
+                $_ = $comprehension->flatMap(static function(...$args) use (&$called) {
                     $called = true;
 
                     return Maybe::just($args[0]);

tests/RegExpTest.php

@@ -32,7 +32,7 @@ public function testThrowWhenInvalidRegexp()
     {
         $this->expectException(LogicException::class);
 
-        RegExp::of('/foo');
+        $_ = RegExp::of('/foo');
     }
 
     public function testMatches()

tests/SequenceTest.php

@@ -1020,7 +1020,7 @@ public function testSafeguard()
         $stop = new \Exception;
 
         try {
-            Sequence::of(1, 2, 3, 1)->safeguard(
+            $_ = Sequence::of(1, 2, 3, 1)->safeguard(
                 Set::of(),
                 static fn($unique, $value) => match ($unique->contains($value)) {
                     true => throw $stop,
@@ -1048,7 +1048,7 @@ public function testSafeguard()
                 },
             );
             $this->assertFalse($loaded);
-            $sequence->toList();
+            $_ = $sequence->toList();
             $this->fail('it should throw');
         } catch (\Exception $e) {
             $this->assertSame($stop, $e);
@@ -1070,7 +1070,7 @@ public function testSafeguard()
                 },
             );
             $this->assertFalse($loaded);
-            $sequence->toList();
+            $_ = $sequence->toList();
             $this->fail('it should throw');
         } catch (\Exception $e) {
             $this->assertSame($stop, $e);
@@ -1134,12 +1134,12 @@ public function testAggregate()
                     $lines->toList(),
                 );
                 $this->assertSame(1, $loaded);
-                $lines->toList();
+                $_ = $lines->toList();
                 $this->assertSame(2, $loaded);
             });
 
         try {
-            Str::of("foo\nbar\nbaz")
+            $_ = Str::of("foo\nbar\nbaz")
                 ->chunk(1)
                 ->aggregate(static fn() => Sequence::of())
                 ->toList();

tests/SetTest.php

@@ -91,7 +91,7 @@ public function testAdd()
         $s = Set::of()->add(42);
 
         $this->assertSame(1, $s->size());
-        $s->add(24);
+        $_ = $s->add(24);
         $this->assertSame(1, $s->size());
         $s = $s->add(24);
         $this->assertInstanceOf(Set::class, $s);
@@ -231,7 +231,7 @@ public function testForeach()
             ->add(4);
         $count = 0;
 
-        $s->foreach(function(int $v) use (&$count) {
+        $_ = $s->foreach(function(int $v) use (&$count) {
             $this->assertSame(++$count, $v);
         });
         $this->assertSame(4, $count);
@@ -557,7 +557,7 @@ public function testSafeguard()
         $stop = new \Exception;
 
         try {
-            Set::of(new \ArrayObject([1]), new \ArrayObject([2]), new \ArrayObject([3]), new \ArrayObject([1]))->safeguard(
+            $_ = Set::of(new \ArrayObject([1]), new \ArrayObject([2]), new \ArrayObject([3]), new \ArrayObject([1]))->safeguard(
                 Set::of(),
                 static fn($unique, $value) => match ($unique->contains($value[0])) {
                     true => throw $stop,
@@ -587,7 +587,7 @@ public function testSafeguard()
                     },
                 );
             $this->assertFalse($loaded);
-            $set->toList();
+            $_ = $set->toList();
             $this->fail('it should throw');
         } catch (\Exception $e) {
             $this->assertSame($stop, $e);
@@ -609,7 +609,7 @@ public function testSafeguard()
                 },
             );
             $this->assertFalse($loaded);
-            $set->toList();
+            $_ = $set->toList();
             $this->fail('it should throw');
         } catch (\Exception $e) {
             $this->assertSame($stop, $e);