Allow specifying multiple exception classes in tryOf() and trap()

Author: kylekatarnls

src/functions/internal.php

@@ -2,6 +2,8 @@
 
 namespace TH\Maybe\Internal;
 
+use function TH\Maybe\Option\isOfAnyClass;
+
 /**
  * Call $callback with $exception if it matches one of $exceptionClasses
  * and return its value, or rethrow it otherwise.
@@ -10,9 +12,9 @@
  * @template T
  * @param E $error
  * @param callable(E): T $callback
- * @param class-string<E> $exceptionClasses
- * @throws \Throwable
+ * @param class-string<E> ...$exceptionClasses
  * @return T
+ * @throws \Throwable
  * @internal
  * @nodoc
  */
@@ -21,10 +23,8 @@ function trap(
     callable $callback,
     string ...$exceptionClasses,
 ): mixed {
-    foreach ($exceptionClasses as $exceptionClass) {
-        if (\is_a($error, $exceptionClass)) {
-            return $callback($error);
-        }
+    if (isOfAnyClass($error, $exceptionClasses)) {
+        return $callback($error);
     }
 
     throw $error;

src/functions/option.php

@@ -116,20 +116,20 @@ function of(callable $callback, mixed $noneValue = null, bool $strict = true): O
  * @template U
  * @template E of \Throwable
  * @param callable():U $callback
- * @param class-string<E> $exceptionClass
+ * @param list<class-string<E>>|class-string<E> $exceptionClass
  * @return Option<U>
  * @throws \Throwable
  */
 function tryOf(
     callable $callback,
     mixed $noneValue = null,
     bool $strict = true,
-    string $exceptionClass = \Exception::class,
+    array|string $exceptionClass = \Exception::class,
 ): Option {
     try {
         return Option\of($callback, $noneValue, $strict);
     } catch (\Throwable $th) {
-        if (\is_a($th, $exceptionClass)) {
+        if (isOfAnyClass($th, (array) $exceptionClass)) {
             return Option\none();
         }
 
@@ -214,3 +214,21 @@ function transpose(Option $option): Result
         static fn () => Result\ok(Option\none()),
     );
 }
+
+/**
+ * Check if the type of the given value is any of the passed classes.
+ *
+ * @param iterable<class-string> $classes
+ */
+function isOfAnyClass(
+    object $value,
+    iterable $classes,
+): bool {
+    foreach ($classes as $class) {
+        if (\is_a($value, $class)) {
+            return true;
+        }
+    }
+
+    return false;
+}

src/functions/result.php

@@ -6,6 +6,7 @@
 use TH\Maybe\Option;
 use TH\Maybe\Result;
 use TH\Maybe\Tests\Helpers\IgnoreUnusedResults;
+use function TH\Maybe\Option\isOfAnyClass;
 
 /**
  * Return a `Result\Ok` Result containing `$value`.
@@ -78,18 +79,18 @@ function err(mixed $value): Result\Err
  * @template U
  * @template E of \Throwable
  * @param callable(mixed...):U $callback
- * @param class-string<E> $exceptionClass
+ * @param list<class-string<E>>|class-string<E> $exceptionClass
  * @return Result<U,E>
  * @throws \Throwable
  */
 #[ExamplesSetup(IgnoreUnusedResults::class)]
-function trap(callable $callback, string $exceptionClass = \Exception::class): Result
+function trap(callable $callback, array|string $exceptionClass = \Exception::class): Result
 {
     try {
         /** @var Result<U,E> */
         return Result\ok($callback());
     } catch (\Throwable $th) {
-        if (\is_a($th, $exceptionClass)) {
+        if (isOfAnyClass($th, (array) $exceptionClass)) {
             return Result\err($th);
         }
 

tests/Unit/Option/OfTest.php

@@ -57,7 +57,7 @@ public function testTryOfDefaultToStrict(): void
         Assert::assertEquals($o, Option\tryOf(static fn () => $o, (object)[])->unwrap());
     }
 
-    public function testTryOfExeptions(): void
+    public function testTryOfExceptions(): void
     {
         // @phpstan-ignore-next-line
         Assert::assertEquals(Option\none(), Option\tryOf(static fn () => new \DateTimeImmutable("nope")));
@@ -69,4 +69,32 @@ public function testTryOfExeptions(): void
         } catch (\DivisionByZeroError) {
         }
     }
+
+    public function testTryOfExceptionsWithExpectedClass(): void
+    {
+        Assert::assertEquals(
+            Option\none(),
+            // @phpstan-ignore-next-line
+            Option\tryOf(static fn () => 1 / 0, exceptionClass: \ArithmeticError::class),
+        );
+        Assert::assertEquals(
+            Option\none(),
+            // @phpstan-ignore-next-line
+            Option\tryOf(static fn () => 1 / 0, exceptionClass: [\LogicException::class, \ArithmeticError::class]),
+        );
+
+        try {
+            // @phpstan-ignore-next-line
+            Option\tryOf(static fn () => 1 / 0, exceptionClass: [\LogicException::class, \RuntimeException::class]);
+            Assert::fail("An exception should have been thrown");
+        } catch (\DivisionByZeroError) {
+        }
+
+        try {
+            // @phpstan-ignore-next-line
+            Option\tryOf(static fn () => 1 / 0, exceptionClass: \LogicException::class);
+            Assert::fail("An exception should have been thrown");
+        } catch (\DivisionByZeroError) {
+        }
+    }
 }