Is Templating in a type definition possible?

[lens0021]

Say, I have the following variables:

/** @psalm-check-type $strWrapper = list<list<string>> */
$strWrapper = [['a']];
/** @psalm-check-type $intWrapper = list<list<int>> */
$intWrapper = [[1]];
/** @psalm-check-type $intWrapper = list<list<float>> */
$floatWrapper = [[1.1]];

Is there a support of templating for a type? What I want would be something similar to:

/** @psalm-type Wrapper<T> = list<list<T>> */

/** @psalm-check-type $strWrapper = Wrapper<string> */
$strWrapper = [['string']];
/** @psalm-check-type $intWrapper = Wrapper<int> */
$intWrapper = [[1]];
/** @psalm-check-type $intWrapper = Wrapper<float> */
$floatWrapper = [[1.1]];

[tayfuryldz]

Psalm does not currently have parameterized type aliases of the form @psalm-type Wrapper<T> = ....

@psalm-type aliases name a concrete type expression; they don't introduce their own template parameter scope. The current docs for @psalm-type only define aliases such as:

/** @psalm-type PhoneType = array{phone: string} */

while @template parameters are declared on templatable declarations such as classes, interfaces, traits, methods/functions.

For this particular shape, the reusable generic boundary therefore needs to be a templated declaration rather than an alias. For example, if the wrapper is part of an API:

/**
 * @template T
 */
final class Wrapper
{
    /** @var list<list<T>> */
    public array $value;

    /** @param list<list<T>> $value */
    public function __construct(array $value)
    {
        $this->value = $value;
    }
}

/** @var Wrapper<string> */
$s = new Wrapper([['a']]);

/** @var Wrapper<int> */
$i = new Wrapper([[1]]);

If you only need aliases and not a wrapper object, the practical alternative is separate concrete aliases (StringWrapper, IntWrapper, etc.), but there isn't currently syntax that lets @psalm-type itself behave like a generic type constructor.

So the proposed Wrapper<T> spelling is reasonable as a feature idea, but it isn't supported type-alias syntax today.