Add contains, exists, toArray

- Update docs

tests/OptionTest.php

@@ -8,6 +8,7 @@ declare(strict_types=1);
 
 namespace Test;
 
+use BadMethodCallException;
 use BitBadger\InspiredByFSharp\Option;
 use InvalidArgumentException;
 use PhpOption\{None, Some};
@@ -85,6 +86,20 @@ class OptionTest extends TestCase
         $this->assertEquals('passed', $value, 'The value should have been obtained from the option');
     }
 
+    #[TestDox('GetOrThrow succeeds with Some')]
+    public function testGetOrThrowSucceedsWithSome(): void
+    {
+        $value = Option::Some('no throw')->getOrThrow(fn() => new BadMethodCallException('oops'));
+        $this->assertEquals('no throw', $value, 'The "Some" value should have been returned');
+    }
+
+    #[TestDox('GetOrThrow succeeds with None')]
+    public function testGetOrThrowSucceedsWithNone(): void
+    {
+        $this->expectException(BadMethodCallException::class);
+        Option::None()->getOrThrow(fn() => new BadMethodCallException('oops'));
+    }
+
     #[TestDox('Bind succeeds with None')]
     public function testBindSucceedsWithNone(): void
     {
@@ -109,6 +124,54 @@ class OptionTest extends TestCase
         $this->assertTrue($bound->isNone(), 'The option should have been None');
     }
 
+    #[TestDox('Contains succeeds with None')]
+    public function testContainsSucceedsWithNone(): void
+    {
+        $this->assertFalse(Option::None()->contains(null), '"None" should always return false');
+    }
+
+    #[TestDox('Contains succeeds with Some when strictly equal')]
+    public function testContainsSucceedsWithSomeWhenStrictlyEqual(): void
+    {
+        $this->assertTrue(Option::Some(3)->contains(3), '"Some" with strict equality should be true');
+    }
+
+    #[TestDox('Contains succeeds with Some when strictly unequal')]
+    public function testContainsSucceedsWithSomeWhenStrictlyUnequal(): void
+    {
+        $this->assertFalse(Option::Some('3')->contains(3), '"Some" with strict equality should be false');
+    }
+
+    #[TestDox('Contains succeeds with Some when loosely equal')]
+    public function testContainsSucceedsWithSomeWhenLooselyEqual(): void
+    {
+        $this->assertTrue(Option::Some('3')->contains(3, strict: false), '"Some" with loose equality should be true');
+    }
+
+    #[TestDox('Contains succeeds with Some when loosely unequal')]
+    public function testContainsSucceedsWithSomeWhenLooselyUnequal(): void
+    {
+        $this->assertFalse(Option::Some('3')->contains(4, strict: false), '"Some" with loose equality should be false');
+    }
+
+    #[TestDox('Exists succeeds with Some when matching')]
+    public function testExistsSucceedsWithSomeWhenMatching(): void
+    {
+        $this->assertTrue(Option::Some(14)->exists(fn($it) => $it < 100), 'Exists should have returned true');
+    }
+
+    #[TestDox('Exists succeeds with Some when not matching')]
+    public function testExistsSucceedsWithSomeWhenNotMatching(): void
+    {
+        $this->assertFalse(Option::Some(14)->exists(fn($it) => $it > 100), 'Exists should have returned false');
+    }
+
+    #[TestDox('Exists succeeds with None')]
+    public function testExistsSucceedsWithNone(): void
+    {
+        $this->assertFalse(Option::None()->exists(fn($it) => true), 'Exists should have returned false');
+    }
+
     #[TestDox('Map succeeds with None')]
     public function testMapSucceedsWithNone(): void
     {
@@ -188,36 +251,6 @@ class OptionTest extends TestCase
         $this->assertTrue($filtered->isNone(), 'The filtered option should have been "None"');
     }
 
-    #[TestDox('Is succeeds with None')]
-    public function testIsSucceedsWithNone(): void
-    {
-        $this->assertFalse(Option::None()->is(null), '"None" should always return false');
-    }
-
-    #[TestDox('Is succeeds with Some when strictly equal')]
-    public function testIsSucceedsWithSomeWhenStrictlyEqual(): void
-    {
-        $this->assertTrue(Option::Some(3)->is(3), '"Some" with strict equality should be true');
-    }
-
-    #[TestDox('Is succeeds with Some when strictly unequal')]
-    public function testIsSucceedsWithSomeWhenStrictlyUnequal(): void
-    {
-        $this->assertFalse(Option::Some('3')->is(3), '"Some" with strict equality should be false');
-    }
-
-    #[TestDox('Is succeeds with Some when loosely equal')]
-    public function testIsSucceedsWithSomeWhenLooselyEqual(): void
-    {
-        $this->assertTrue(Option::Some('3')->is(3, strict: false), '"Some" with loose equality should be true');
-    }
-
-    #[TestDox('Is succeeds with Some when loosely unequal')]
-    public function testIsSucceedsWithSomeWhenLooselyUnequal(): void
-    {
-        $this->assertFalse(Option::Some('3')->is(4, strict: false), '"Some" with loose equality should be false');
-    }
-
     #[TestDox('Unwrap succeeds with None')]
     public function testUnwrapSucceedsWithNone(): void
     {
@@ -252,6 +285,22 @@ class OptionTest extends TestCase
         $this->assertSame($original, $tapped, 'The same option should have been returned');
     }
 
+    #[TestDox('ToArray succeeds with Some')]
+    public function testToArraySucceedsWithSome(): void
+    {
+        $arr = Option::Some('15')->toArray();
+        $this->assertNotNull($arr, 'The array should not have been null');
+        $this->assertEquals(['15'], $arr, 'The array was not created correctly');
+    }
+
+    #[TestDox('ToArray succeeds with None')]
+    public function testToArraySucceedsWithNone(): void
+    {
+        $arr = Option::None()->toArray();
+        $this->assertNotNull($arr, 'The array should not have been null');
+        $this->assertEmpty($arr, 'The array should have been empty');
+    }
+
     #[TestDox('ToPhpOption succeeds for Some')]
     public function testToPhpOptionSucceedsForSome(): void
     {

tests/ResultTest.php

@@ -99,6 +99,55 @@ class ResultTest extends TestCase
         $this->assertSame($original, $result, 'The same Error result should have been returned');
     }
 
+
+    #[TestDox('Contains succeeds for Error result')]
+    public function testContainsSucceedsForErrorResult(): void
+    {
+        $this->assertFalse(Result::Error('ouch')->contains('ouch'), '"Error" should always return false');
+    }
+
+    #[TestDox('Contains succeeds for OK result when strictly equal')]
+    public function testContainsSucceedsForOKResultWhenStrictlyEqual(): void
+    {
+        $this->assertTrue(Result::OK(18)->contains(18), '"OK" with strict equality should be true');
+    }
+
+    #[TestDox('Contains succeeds for OK result when strictly unequal')]
+    public function testContainsSucceedsForOKResultWhenStrictlyUnequal(): void
+    {
+        $this->assertFalse(Result::OK(18)->contains('18'), '"OK" with strict equality should be false');
+    }
+
+    #[TestDox('Contains succeeds for OK result when loosely equal')]
+    public function testContainsSucceedsForOKResultWhenLooselyEqual(): void
+    {
+        $this->assertTrue(Result::OK(18)->contains('18', strict: false), '"OK" with loose equality should be true');
+    }
+
+    #[TestDox('Contains succeeds for OK result when loosely unequal')]
+    public function testContainsSucceedsForOKResultWhenLooselyUnequal(): void
+    {
+        $this->assertFalse(Result::OK(18)->contains(17, strict: false), '"OK" with loose equality should be false');
+    }
+
+    #[TestDox('Exists succeeds for OK result when matching')]
+    public function testExistsSucceedsForOKResultWhenMatching(): void
+    {
+        $this->assertTrue(Result::OK(14)->exists(fn($it) => $it < 100), 'Exists should have returned true');
+    }
+
+    #[TestDox('Exists succeeds for OK result when not matching')]
+    public function testExistsSucceedsForOKResultWhenNotMatching(): void
+    {
+        $this->assertFalse(Result::OK(14)->exists(fn($it) => $it > 100), 'Exists should have returned false');
+    }
+
+    #[TestDox('Exists succeeds for Error result')]
+    public function testExistsSucceedsForErrorResult(): void
+    {
+        $this->assertFalse(Result::Error(true)->exists(fn($it) => true), 'Exists should have returned false');
+    }
+
     #[TestDox('Map succeeds for OK result')]
     public function testMapSucceedsForOKResult(): void
     {
@@ -177,6 +226,22 @@ class ResultTest extends TestCase
         $this->assertNull($target->called, 'The function should not have been called');
     }
 
+    #[TestDox('ToArray succeeds for OK result')]
+    public function testToArraySucceedsForOKResult(): void
+    {
+        $arr = Result::OK('yay')->toArray();
+        $this->assertNotNull($arr, 'The array should not have been null');
+        $this->assertEquals(['yay'], $arr, 'The array was not created correctly');
+    }
+
+    #[TestDox('ToArray succeeds for Error result')]
+    public function testToArraySucceedsForErrorResult(): void
+    {
+        $arr = Result::Error('oh no')->toArray();
+        $this->assertNotNull($arr, 'The array should not have been null');
+        $this->assertEmpty($arr, 'The array should have been empty');
+    }
+
     #[TestDox('ToOption succeeds for OK result')]
     public function testToOptionSucceedsForOKResult()
     {