feat: introduce composite types

Composite types are composed of other types and must now implement a
method to recursively traverse all sub-types.

src/Type/CombiningType.php

@@ -5,7 +5,7 @@
 namespace CuyZ\Valinor\Type;
 
 /** @api */
-interface CombiningType extends Type
+interface CombiningType extends CompositeType
 {
     public function isMatchedBy(Type $other): bool;
 

src/Type/CompositeTraversableType.php

@@ -7,7 +7,7 @@
 use CuyZ\Valinor\Type\Types\ArrayKeyType;
 
 /** @api */
-interface CompositeTraversableType extends Type
+interface CompositeTraversableType extends CompositeType
 {
     public function keyType(): ArrayKeyType;
 

src/Type/CompositeType.php

@@ -0,0 +1,14 @@
+<?php
+
+declare(strict_types=1);
+
+namespace CuyZ\Valinor\Type;
+
+/** @api */
+interface CompositeType extends Type
+{
+    /**
+     * @return iterable<Type>
+     */
+    public function traverse(): iterable;
+}

src/Type/Types/ArrayType.php

@@ -5,6 +5,7 @@
 namespace CuyZ\Valinor\Type\Types;
 
 use CuyZ\Valinor\Type\CompositeTraversableType;
+use CuyZ\Valinor\Type\CompositeType;
 use CuyZ\Valinor\Type\Type;
 
 use function is_array;
@@ -98,6 +99,15 @@ public function subType(): Type
         return $this->subType;
     }
 
+    public function traverse(): iterable
+    {
+        yield $this->subType;
+
+        if ($this->subType instanceof CompositeType) {
+            yield from $this->subType->traverse();
+        }
+    }
+
     public function __toString(): string
     {
         return $this->signature;

src/Type/Types/ClassType.php

@@ -5,12 +5,13 @@
 namespace CuyZ\Valinor\Type\Types;
 
 use CuyZ\Valinor\Type\ObjectType;
+use CuyZ\Valinor\Type\CompositeType;
 use CuyZ\Valinor\Type\Type;
 
 use function is_a;
 
 /** @api */
-final class ClassType implements ObjectType
+final class ClassType implements ObjectType, CompositeType
 {
     /** @var class-string */
     private string $className;
@@ -64,6 +65,17 @@ public function matches(Type $other): bool
         return is_a($this->className, $other->className(), true);
     }
 
+    public function traverse(): iterable
+    {
+        foreach ($this->generics as $type) {
+            yield $type;
+
+            if ($type instanceof CompositeType) {
+                yield from $type->traverse();
+            }
+        }
+    }
+
     public function __toString(): string
     {
         return empty($this->generics)

src/Type/Types/IntersectionType.php

@@ -6,6 +6,7 @@
 
 use CuyZ\Valinor\Type\CombiningType;
 use CuyZ\Valinor\Type\ObjectType;
+use CuyZ\Valinor\Type\CompositeType;
 use CuyZ\Valinor\Type\Type;
 
 use function implode;
@@ -65,6 +66,17 @@ public function isMatchedBy(Type $other): bool
         return true;
     }
 
+    public function traverse(): iterable
+    {
+        foreach ($this->types as $type) {
+            yield $type;
+
+            if ($type instanceof CompositeType) {
+                yield from $type->traverse();
+            }
+        }
+    }
+
     /**
      * @return ObjectType[]
      */

src/Type/Types/IterableType.php

@@ -5,6 +5,7 @@
 namespace CuyZ\Valinor\Type\Types;
 
 use CuyZ\Valinor\Type\CompositeTraversableType;
+use CuyZ\Valinor\Type\CompositeType;
 use CuyZ\Valinor\Type\Type;
 
 use function is_iterable;
@@ -84,6 +85,15 @@ public function subType(): Type
         return $this->subType;
     }
 
+    public function traverse(): iterable
+    {
+        yield $this->subType;
+
+        if ($this->subType instanceof CompositeType) {
+            yield from $this->subType->traverse();
+        }
+    }
+
     public function __toString(): string
     {
         return $this->signature;

src/Type/Types/ListType.php

@@ -5,6 +5,7 @@
 namespace CuyZ\Valinor\Type\Types;
 
 use CuyZ\Valinor\Type\CompositeTraversableType;
+use CuyZ\Valinor\Type\CompositeType;
 use CuyZ\Valinor\Type\Type;
 
 use function is_array;
@@ -91,6 +92,15 @@ public function subType(): Type
         return $this->subType;
     }
 
+    public function traverse(): iterable
+    {
+        yield $this->subType;
+
+        if ($this->subType instanceof CompositeType) {
+            yield from $this->subType->traverse();
+        }
+    }
+
     public function __toString(): string
     {
         return $this->signature;

src/Type/Types/NonEmptyArrayType.php

@@ -5,6 +5,7 @@
 namespace CuyZ\Valinor\Type\Types;
 
 use CuyZ\Valinor\Type\CompositeTraversableType;
+use CuyZ\Valinor\Type\CompositeType;
 use CuyZ\Valinor\Type\Type;
 
 use function is_array;
@@ -94,6 +95,15 @@ public function subType(): Type
         return $this->subType;
     }
 
+    public function traverse(): iterable
+    {
+        yield $this->subType;
+
+        if ($this->subType instanceof CompositeType) {
+            yield from $this->subType->traverse();
+        }
+    }
+
     public function __toString(): string
     {
         return $this->signature;

src/Type/Types/NonEmptyListType.php

@@ -5,6 +5,7 @@
 namespace CuyZ\Valinor\Type\Types;
 
 use CuyZ\Valinor\Type\CompositeTraversableType;
+use CuyZ\Valinor\Type\CompositeType;
 use CuyZ\Valinor\Type\Type;
 
 use function count;
@@ -99,6 +100,15 @@ public function subType(): Type
         return $this->subType;
     }
 
+    public function traverse(): iterable
+    {
+        yield $this->subType;
+
+        if ($this->subType instanceof CompositeType) {
+            yield from $this->subType->traverse();
+        }
+    }
+
     public function __toString(): string
     {
         return $this->signature;

src/Type/Types/ShapedArrayType.php

@@ -6,7 +6,7 @@
 
 use CuyZ\Valinor\Type\CompositeTraversableType;
 use CuyZ\Valinor\Type\Parser\Exception\Iterable\ShapedArrayElementDuplicatedKey;
-use CuyZ\Valinor\Type\TraversableType;
+use CuyZ\Valinor\Type\CompositeType;
 use CuyZ\Valinor\Type\Type;
 
 use function array_diff;
@@ -18,7 +18,7 @@
 use function is_array;
 
 /** @api */
-final class ShapedArrayType implements TraversableType
+final class ShapedArrayType implements CompositeType
 {
     /** @var ShapedArrayElement[] */
     private array $elements;
@@ -120,6 +120,17 @@ public function matches(Type $other): bool
         return true;
     }
 
+    public function traverse(): iterable
+    {
+        foreach ($this->elements as $element) {
+            yield $type = $element->type();
+
+            if ($type instanceof CompositeType) {
+                yield from $type->traverse();
+            }
+        }
+    }
+
     /**
      * @return ShapedArrayElement[]
      */

src/Type/Types/UnionType.php

@@ -5,6 +5,7 @@
 namespace CuyZ\Valinor\Type\Types;
 
 use CuyZ\Valinor\Type\CombiningType;
+use CuyZ\Valinor\Type\CompositeType;
 use CuyZ\Valinor\Type\Type;
 use CuyZ\Valinor\Type\Types\Exception\ForbiddenMixedType;
 
@@ -82,6 +83,17 @@ public function isMatchedBy(Type $other): bool
         return false;
     }
 
+    public function traverse(): iterable
+    {
+        foreach ($this->types as $type) {
+            yield $type;
+
+            if ($type instanceof CompositeType) {
+                yield from $type->traverse();
+            }
+        }
+    }
+
     public function types(): array
     {
         return $this->types;

tests/Fake/Type/FakeCompositeType.php

@@ -0,0 +1,39 @@
+<?php
+
+declare(strict_types=1);
+
+namespace CuyZ\Valinor\Tests\Fake\Type;
+
+use CuyZ\Valinor\Type\CompositeType;
+use CuyZ\Valinor\Type\Type;
+
+final class FakeCompositeType implements CompositeType
+{
+    /** @var Type[] */
+    private array $types;
+
+    public function __construct(Type ...$types)
+    {
+        $this->types = $types;
+    }
+
+    public function traverse(): iterable
+    {
+        yield from $this->types;
+    }
+
+    public function accepts($value): bool
+    {
+        return true;
+    }
+
+    public function matches(Type $other): bool
+    {
+        return true;
+    }
+
+    public function __toString(): string
+    {
+        return 'FakeCompositeType';
+    }
+}

tests/Fake/Type/FakeObjectCompositeType.php

@@ -0,0 +1,59 @@
+<?php
+
+declare(strict_types=1);
+
+namespace CuyZ\Valinor\Tests\Fake\Type;
+
+use CuyZ\Valinor\Type\CompositeType;
+use CuyZ\Valinor\Type\ObjectType;
+use CuyZ\Valinor\Type\Type;
+use stdClass;
+
+final class FakeObjectCompositeType implements ObjectType, CompositeType
+{
+    /** @var class-string */
+    private string $className;
+
+    /** @var array<string, Type> */
+    private array $generics;
+
+    /**
+     * @param class-string $className
+     * @param array<string, Type> $generics
+     */
+    public function __construct(string $className = stdClass::class, array $generics = [])
+    {
+        $this->className = $className;
+        $this->generics = $generics;
+    }
+
+    public function className(): string
+    {
+        return $this->className;
+    }
+
+    public function generics(): array
+    {
+        return $this->generics;
+    }
+
+    public function accepts($value): bool
+    {
+        return true;
+    }
+
+    public function matches(Type $other): bool
+    {
+        return true;
+    }
+
+    public function traverse(): iterable
+    {
+        yield from $this->generics;
+    }
+
+    public function __toString(): string
+    {
+        return $this->className;
+    }
+}