Removed TypedOptional helper

README.md

@@ -17,7 +17,6 @@ It is an easy way to make sure that everyone has to check if they have (not) rec
 ```php
 use PetrKnap\Optional\Optional;
 
-/** @var Optional<string> $stringOption */
 $stringOption = Optional::of('data');
 if ($stringOption->isPresent()) {
     echo $stringOption->get();
@@ -30,48 +29,24 @@ Optional::ofFalsable(tmpfile())->ifPresent(function ($tmpFile): void {
 ```
 
 
-## Creating your own typed optional
+## Creating your own optional
 
-The library provides specialized traits to help you implement strictly typed wrappers with full static analysis support.
+This library provides [`OptionalOverrides` trait](src/OptionalOverrides.php) to help you implement your own wrapper with full static analysis support (see [`Some\Optional` class](./tests/Some/Optional.php)):
 
-### Quick Overview
-
-1. **[`NonGenericOptional` trait](./src/NonGenericOptional.php)** for fixed specific types like `bool` or `string` (see [`OptionalString` class](./tests/Some/OptionalString.php))
-   ```php
-   use PetrKnap\Optional\Optional;
-   use PetrKnap\Optional\NonGenericOptional;
-
-   /** @extends Optional<bool> */
-   final class OptionalBool extends Optional
-   {
-       use NonGenericOptional;
-
-       protected static function isSupported(mixed $value): bool
-       {
-           return is_bool($value);
-       }
-   }
-   ```
-2. **[`GenericOptional` trait](./src/GenericOptional.php)** for generic structures like `array` (see [`OptionalArray` class](./tests/Some/OptionalArray.php))
-3. **[`AbstractOptional` trait](./src/AbstractOptional.php)** for extendable factory optionals (use this when you need a base class for other typed optionals, see [`OptionalObject` class](./tests/Some/OptionalObject.php))
-
-### Type registration
-
-You can register your custom typed optionals into [`TypedOptional` helper](./src/TypedOptional.php).
-Once registered, calling the base [`Optional` class](./src/Optional.php) will automatically look up and return the correct specific subclass if the value matches its criteria.
 ```php
-use PetrKnap\Optional\TypedOptional;
 use PetrKnap\Optional\Optional;
-
-TypedOptional::register(OptionalBool::class);
-
-printf(
-    "Class name of optional which holds `true` is `%s`.\n",
-    get_class(Optional::of(true)),
-);
-```
-```
-Class name of optional which holds `true` is `OptionalBool`.
+use PetrKnap\Optional\OptionalOverrides;
+
+/**
+ * @template-covariant T of mixed type of non-null value
+ *
+ * @extends Optional<T>
+ */
+final class MyOptional extends Optional
+{
+   /** @use OptionalOverrides<T> */
+   use OptionalOverrides;
+}
 ```
 
 ---

composer.json

@@ -7,10 +7,7 @@
   "autoload-dev": {
     "psr-4": {
       "PetrKnap\\Optional\\": "tests"
-    },
-    "files": [
-      "tests/Some/typed_optionals.php"
-    ]
+    }
   },
   "config": {
     "allow-plugins": false,

src/Optional.php

@@ -22,9 +22,6 @@ abstract class Optional implements JavaSe8\Optional
     final protected function __construct(
         protected readonly mixed $value,
     ) {
-        if ($this->value !== null && !@static::isSupported($this->value)) {
-            throw new InvalidArgumentException('Value is not supported.');
-        }
     }
 
     /**
@@ -84,19 +81,8 @@ public static function ofFalsable(mixed $value): self
     public static function ofNullable(mixed $value): self
     {
         if (static::class === Optional::class) {
-            if ($value !== null) {
-                try {
-                    /** @var self<U> */
-                    return TypedOptional::of($value, Optional::class);
-                } catch (Exception\CouldNotFindTypedOptionalForValue) {
-                }
-            }
             /** @var self<U> */
             return new class ($value) extends Optional {
-                protected static function isSupported(mixed $value): bool
-                {
-                    return true;
-                }
             };
         }
         return new static($value);
@@ -221,11 +207,9 @@ public function isPresent(): bool
      *
      * @param callable(T): U $mapper
      *
-     * @return Optional<U>
-     *
-     * @note do not use {@see self}/{@see static}, it maps itself to another {@see Optional}
+     * @return self<U>
      */
-    public function map(callable $mapper): Optional
+    public function map(callable $mapper): self
     {
         /** @var callable(T): Optional<U> $flatMapper */
         $flatMapper = static function (mixed $value) use ($mapper): Optional {
@@ -246,11 +230,8 @@ public function orElseGet(callable $otherSupplier): mixed
         if ($this->value !== null) {
             return $this->value;
         }
-        /** @var T|null $other */
-        $other = $otherSupplier();
-        return $other === null || static::isSupported($other)
-            ? $other
-            : throw new InvalidArgumentException('Other supplier must return supported other.');
+        /** @var T|null */
+        return $otherSupplier();
     }
 
     /**
@@ -294,11 +275,6 @@ public function orElseThrow(
         });
     }
 
-    /**
-     * @param mixed $value not null
-     */
-    abstract protected static function isSupported(mixed $value): bool;
-
     private static function triggerNotice(string $message): void
     {
         trigger_error(