Improve API

Author: vudaltsov

composer.json

@@ -71,7 +71,7 @@
         ],
         "infection": "tools/infection/vendor/bin/infection --show-mutations",
         "normalize": "@composer bin composer-normalize normalize --diff ../../composer.json",
-        "phpstan": "tools/phpstan/vendor/bin/phpstan analyze",
+        "phpstan": "tools/phpstan/vendor/bin/phpstan analyze --memory-limit=-1",
         "pre-command-run": "mkdir -p var",
         "psalm": "tools/psalm/vendor/bin/psalm --show-info --no-diff --no-cache",
         "rector": "tools/rector/vendor/bin/rector process",

generator/Visitor/Stringify.php

@@ -100,7 +100,7 @@ public function listT(ListT $type): string
     {
         $value = $type->value->accept($this);
 
-        $elements = $this->arrayElements($type->elements);
+        $elements = implode(', ', array_map(fn(Type $type): string => $type->accept($this), $type->elements));
 
         if ($value === 'never') {
             return \sprintf('list{%s}', $elements);
@@ -122,7 +122,7 @@ public function arrayT(ArrayT $type): string
     {
         $value = $type->value->accept($this);
 
-        $elements = $this->arrayElements($type->elements);
+        $elements = implode(', ', array_map($this->arrayElement(...), $type->elements));
 
         if ($value === 'never') {
             return \sprintf('array{%s}', $elements);
@@ -145,27 +145,16 @@ public function arrayT(ArrayT $type): string
     }
 
     /**
-     * @param array<ArrayElement> $elements
+     * @return non-empty-string
      */
-    private function arrayElements(array $elements): string
+    protected function arrayElement(ArrayElement $element): string
     {
-        if (array_is_list($elements) && array_all($elements, static fn(ArrayElement $e) => !$e->isOptional)) {
-            return implode(', ', array_map(
-                fn(ArrayElement $element): string => $element->type->accept($this),
-                $elements,
-            ));
-        }
-
-        return implode(', ', array_map(
-            fn(int|string $key, ArrayElement $element): string => \sprintf(
-                '%s%s: %s',
-                \is_int($key) ? $key : $this->stringValueT(new StringValueT($key)),
-                $element->isOptional ? '?' : '',
-                $element->type->accept($this),
-            ),
-            array_keys($elements),
-            $elements,
-        ));
+        return \sprintf(
+            '%s%s: %s',
+            \is_int($element->key) ? $element->key : $this->stringValueT(new StringValueT($element->key)),
+            $element->isOptional ? '?' : '',
+            $element->type->accept($this),
+        );
     }
 
     #[\Override]
@@ -208,7 +197,7 @@ public function objectT(ObjectT $type): string
     /**
      * @return non-empty-string
      */
-    private function property(Property $property): string
+    protected function property(Property $property): string
     {
         return \sprintf('%s%s: %s', $property->name, $property->isOptional ? '?' : '', $property->type->accept($this));
     }
@@ -256,7 +245,7 @@ public function callableT(CallableT $type): string
             'callable%s(%s): %s',
             $this->templates($type->templates),
             implode(', ', array_map($this->parameter(...), $type->parameters)),
-            $type->returns->accept($this),
+            $type->return->accept($this),
         );
     }
 
@@ -267,31 +256,52 @@ public function closureT(ClosureT $type): string
             'Closure%s(%s): %s',
             $this->templates($type->templates),
             implode(', ', array_map($this->parameter(...), $type->parameters)),
-            $type->returns->accept($this),
+            $type->return->accept($this),
         );
     }
 
     /**
      * @return non-empty-string
      */
-    private function parameter(Parameter $parameter): string
+    protected function parameter(Parameter $parameter): string
     {
-        /** @phpstan-ignore return.type */
-        return \sprintf(
-            '%s%s%s%s',
-            $parameter->type->accept($this),
-            $parameter->isPassedByReference ? '&' : '',
-            $parameter->isVariadic ? '...' : '',
-            $parameter->hasDefault ? '=' : '',
-        );
+        $string = $parameter->type->accept($this);
+
+        if ($parameter->name !== null) {
+            $string .= ' ';
+        }
+
+        if ($parameter->isPassedByReference) {
+            $string .= '&';
+
+            // todo $parameter->outType
+        }
+
+        if ($parameter->isVariadic) {
+            $string .= '...';
+        }
+
+        if ($parameter->name !== null) {
+            $string .= '$' . $parameter->name;
+        }
+
+        if ($parameter->hasDefault) {
+            $string .= '=';
+
+            if ($parameter->defaultType !== null) {
+                $string .= $parameter->defaultType->accept($this);
+            }
+        }
+
+        return $string;
     }
 
     /**
      * @param non-empty-string $name
      * @param list<Type> $templateArguments
      * @return non-empty-string
      */
-    private function constructor(string $name, array $templateArguments): string
+    protected function constructor(string $name, array $templateArguments): string
     {
         if ($templateArguments === []) {
             return $name;
@@ -384,7 +394,7 @@ public function ternaryT(TernaryT $type): string
     /**
      * @param list<Template> $templates
      */
-    private function templates(array $templates): string
+    protected function templates(array $templates): string
     {
         if ($templates === []) {
             return '';
@@ -393,13 +403,13 @@ private function templates(array $templates): string
         return \sprintf('<%s>', implode(', ', array_map($this->template(...), $templates)));
     }
 
-    private function template(Template $template): string
+    protected function template(Template $template): string
     {
         $lowerBound = $template->lowerBound->accept($this);
         $upperBound = $template->upperBound->accept($this);
 
         return \sprintf(
-            '%s%s%s%s',
+            '%s%s%s%s%s',
             match ($template->variance) {
                 Variance::Invariant => '',
                 Variance::Covariant => 'out ',
@@ -408,6 +418,7 @@ private function template(Template $template): string
             $this->templateNames()[$template->type] ??= $template->name,
             $upperBound === 'mixed' ? '' : ' of ' . $upperBound,
             $lowerBound === 'never' ? '' : ' super ' . $lowerBound,
+            $template->default === null ? '' : ' = ' . $template->default->accept($this),
         );
     }
 
@@ -417,7 +428,7 @@ private function template(Template $template): string
     /**
      * @return \SplObjectStorage<TemplateT, non-empty-string>
      */
-    private function templateNames(): \SplObjectStorage
+    final protected function templateNames(): \SplObjectStorage
     {
         if ($this->templateNames !== null) {
             return $this->templateNames;

generator/spec.php

@@ -43,9 +43,9 @@
     single('numeric', 'numeric', 'union([int, float, numericString])'),
     single('scalar', 'scalar', 'union([bool, int, float, string])'),
     // array
-    constr('list', 'list<V>', [tpl('V')], [prop('value', 'Type<V>', MixedT::T), prop('elements', 'list<ArrayElement>'), prop('isNonEmpty', 'bool')]),
+    constr('list', 'T', [tpl('T', 'list')], [prop('value', 'Type', MixedT::T), prop('elements', 'list<Type>'), prop('isNonEmpty', 'bool')]),
     single('arrayDefault', 'array', 'array()'),
-    constr('array', 'array<K, V>', [tpl('K', 'array-key'), tpl('V')], [prop('key', 'Type<K>', ArrayKeyT::T), prop('value', 'Type<V>', MixedT::T), prop('elements', 'array<ArrayElement>'), prop('isNonEmpty', 'bool')]),
+    constr('array', 'T', [tpl('T', 'array')], [prop('key', 'Type', ArrayKeyT::T), prop('value', 'Type', MixedT::T), prop('elements', 'list<ArrayElement>'), prop('isNonEmpty', 'bool')]),
     // object
     single('objectDefault', 'object', 'object()'),
     constr('namedObject', 'T', [tpl('T', 'object')], [prop('class', 'class-string<T>'), prop('templateArguments', 'list<Type>')], 'object(superTypes: [$t])'),
@@ -61,9 +61,9 @@
     constr('iterable', 'iterable<K, V>', [tpl('K'), tpl('V')], [prop('key', 'Type<K>', MixedT::T), prop('value', 'Type<V>', MixedT::T)]),
     // callable
     single('callableDefault', 'callable', 'callable()'),
-    constr('callable', 'T', [tpl('T', 'callable')], [prop('templates', 'list<Template<Variance::Invariant>>'), prop('parameters', 'list<Parameter>'), prop('returns', 'Type', MixedT::T)]),
+    constr('callable', 'T', [tpl('T', 'callable')], [prop('templates', 'list<Template<Variance::Invariant>>'), prop('parameters', 'list<Parameter>'), prop('return', 'Type', MixedT::T)]),
     single('closureDefault', 'Closure', 'namedObject(Closure::class)'),
-    constr('closure', 'T', [tpl('T', 'Closure')], [prop('templates', 'list<Template<Variance::Invariant>>'), prop('parameters', 'list<Parameter>'), prop('returns', 'Type', MixedT::T)], "intersection([\nclosureDefault,\ncallable(\$templates, \$parameters, \$returns),\n])"),
+    constr('closure', 'T', [tpl('T', 'Closure')], [prop('templates', 'list<Template<Variance::Invariant>>'), prop('parameters', 'list<Parameter>'), prop('return', 'Type', MixedT::T)], "intersection([\nclosureDefault,\ncallable(\$templates, \$parameters, \$return),\n])"),
     // resource
     single('resource', 'resource'),
     // intersection

src/ArrayElement.php

@@ -10,6 +10,7 @@
 final readonly class ArrayElement
 {
     public function __construct(
+        public int|string $key,
         public Type $type,
         public bool $isOptional = false,
     ) {}

src/ArrayT.php

@@ -10,17 +10,14 @@
 
 /**
  * @api
- * @template-covariant K of array-key = array-key
- * @template-covariant V = mixed
- * @implements Type<array<K, V>>
+ * @template-covariant T of array = array
+ * @implements Type<T>
  * @codeCoverageIgnore
  */
 final readonly class ArrayT implements Type
 {
     /**
-     * @param Type<K> $key
-     * @param Type<V> $value
-     * @param array<ArrayElement> $elements
+     * @param list<ArrayElement> $elements
      */
     public function __construct(
         public Type $key = ArrayKeyT::T,

src/CallableT.php

@@ -23,7 +23,7 @@
     public function __construct(
         public array $templates = [],
         public array $parameters = [],
-        public Type $returns = MixedT::T,
+        public Type $return = MixedT::T,
     ) {}
 
     #[\Override]

src/ClosureT.php

@@ -25,7 +25,7 @@
     public function __construct(
         public array $templates = [],
         public array $parameters = [],
-        public Type $returns = MixedT::T,
+        public Type $return = MixedT::T,
     ) {}
 
     #[\Override]

src/Internal/Is.php

@@ -230,25 +230,25 @@ public function arrayT(ArrayT $type): mixed
             return false;
         }
 
-        foreach ($type->elements as $key => $element) {
-            if (!\array_key_exists($key, $this->value)) {
+        $remainingElements = $this->value;
+
+        foreach ($type->elements as $element) {
+            if (!\array_key_exists($element->key, $this->value)) {
                 if ($element->isOptional) {
                     continue;
                 }
 
                 return false;
             }
 
-            if (!is($this->value[$key], $element->type)) {
+            if (!is($this->value[$element->key], $element->type)) {
                 return false;
             }
-        }
 
-        foreach ($this->value as $key => $value) {
-            if (isset($type->elements[$key])) {
-                continue;
-            }
+            unset($remainingElements[$element->key]);
+        }
 
+        foreach ($remainingElements as $key => $value) {
             /** @phpstan-ignore function.alreadyNarrowedType, function.alreadyNarrowedType */
             if (!is($key, $type->key) || !is($value, $type->value)) {
                 return false;

src/ListT.php

@@ -10,15 +10,14 @@
 
 /**
  * @api
- * @template-covariant V = mixed
- * @implements Type<list<V>>
+ * @template-covariant T of list = list
+ * @implements Type<T>
  * @codeCoverageIgnore
  */
 final readonly class ListT implements Type
 {
     /**
-     * @param Type<V> $value
-     * @param list<ArrayElement> $elements
+     * @param list<Type> $elements
      */
     public function __construct(
         public Type $value = MixedT::T,

src/Optional.php

@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Typhoon\Type;
+
+/**
+ * @internal
+ */
+final readonly class Optional
+{
+    public function __construct(
+        public Type $type,
+    ) {}
+}