【PHP next】PHPにおけるジェネリクスの現状 #日本語訳 – Qiita

ジェネリクスを使用することで、プロパティ・メソッドの型プレースホルダを持つクラスを定義できます。
プレースホルダは、クラスをインスタンス化するときに指定します。
これによって、異なるデータ型間でのコードの再利用性や型安全性が実現します。

“具象化”ジェネリクスは、型情報が定義され、実行時に継承される実装であり、実行時にジェネリクスの要件を満たすことができます。
PHPで表すと以下のようになります。

class EntryKeyType, ValueType>
{
    public function __construct(protected KeyType $key, protected ValueType $value)
    {
    }

    public function getKey(): KeyType
    {
        return $this->key;
    }

    public function getValue(): ValueType
    {
        return $this->value;
    }
}

new Entryint, BlogPost>(123, new BlogPost());

インスタンスでは、ジェネリクス型KeyTypeはintに置き換えられ、ValueTypeはBlogPostに置き換えられます。
最終的に、以下のように動作するオブジェクトが生成されます。

class IntBlogPostEntry
{
    public function __construct(protected int $key, protected BlogPost $value)
    {
    }

    public function getKey(): int
    {
        return $this->key;
    }

    public function getValue(): BlogPost
    {
        return $this->value;
    }
}

この機能をPHPに追加する試みは過去幾度もありました。
Nikita Popovは、2016年のRFCおよび残された課題を踏まえ、2020年ごろに最も包括的な実装を試みました。

2024年はじめ、PHPファウンデーション支援の下で、Arnaud Le Blancがこの取り組みを再開しました。
技術的問題の多くは解決されたものの、さらに多くの問題が未解決のまま残っています。

深刻な問題のひとつが型推論です。
ジェネリクス型を使用すると、ジェネリクス型を参照するたびにジェネリクス型を指定する必要があるため、コードの冗長性が増加します。
たとえば以下のようになります。

function f(ListEntryint,BlogPost>> $entries): Mapint, BlogPost>
{
    return new Mapint, BlogPost>($entries);
}

function g(ListBlogPostId> $ids): ListBlogPost>
{
    return mapint, BlogPostId, BlogPost>($ids, $repository->find(...));
}

型推論では、コンパイラが適切な型を自動的に推論することによってこの問題を軽減します。
たとえば上記例では、new Map()やmap()の引数の型はコンパイラが自動的に決定させるべきでしょう。

ところがPHPではこれが困難です。
Nikitaの言葉を借りると、「PHPコンパイラが持っているコードビューは非常に限られている(一度に1ファイルしか認識できない)」

以下の例を考えてみましょう。

class BoxT>
{
    public function __construct(public T $value) {}
}

new Box(getValue());

getValue()の返り値の型は、実際に実行されるまで不明です。
従って、コンパイル時にBoxの型Tを推論することができません。

関数の戻り値に基いて実行時に型Tを決定する場合は、型付けが不安定になります。
上記例では、new Box()'の型はgetValue()`の戻り値に依存しており、特殊すぎる型です。
Boxは不変であることを考えると、このBoxインスタンスを使って何かをしようとするコードはすぐ動かなくなるでしょう。

interface ValueInterface {}
class A implements ValueInterface {}
class B implements ValueInterface {}

function getValue(): ValueInterface
{
    return new A();
}

function doSomething(BoxValueInterface> $box)
{
}

$box = new Box(getValue()) // 動的: Box 静的: Box
doSomething($box); // Boxを受け入れる。 Boxではない。

型付けは、実装に依存しない、コンパイル時に解決する情報に基づいている場合に最も有用です。

ジェネリッククラスが不変であるとは、その型プレースホルダが読み取りと書き込みの両方で同時に使用されている場合に不変です。
プロパティ型は読み取りと書き込みの両方で使用されます。

次の例を考えてみましょう。

function changeValue(BoxValueInterface> $box)
{
    $box->value = new B();
}

関数changeValue()の型はBoxであり、ValueInterfaceの任意のサブタイプを受け入れられます。
ところがValueInterfaceのサブタイプであるAを渡すと、$box->valueにはAのサブタイプでない型Bが代入されることになってしまい、制約が破られてしまいます。

他言語における一般的な解決法は、型パラメータが読み取りと書き込みの片方だけで使用される場合は、一方向のみ可能にするマーク(通常はin/out)をつけることです。
これによって、その型パラメータは共変・反変になります。

Hybrid Approach to Type Inference

class Article
{
    public function __construct(public string $subject) {}
}

collection(Seq) ArticlesArticle>
{
}

collection(Dict) YearBooksint => Book>
{
}

$a1 = new Articles();
$b1 = new YearBooks();

class A {}
class B extends A {}

seq AsA> {}
seq BsB> {}

new B() instanceof A   // true
new Bs() instanceof As // false

namespace Foo;
seq AsA> {}

namespace Bar;
seq AsA> {}

namespace;
new Foo\As instanceof Bar\As; // false

/**
 * @template Key
 * @template Value
 */
class Dict
{
    /**
     * @param array $entries
     */
    public function __construct(private array $entries) {}

    /**
     * @param Key $key
     * @param Value $value
     */
    public function set($key, $value): self
    {
        $this->entries[$key] = $value;
        return $this;
    }
}

/** @param Dict $dict */
function f($dict) {}

$dict = new Dict([1 => 'foo']);
$dict->set("foo", "bar"); // Static analyser error
$dict->set(1, "bar");     // Ok
f($dict);                 // Static analyser error

class DictKey,Value>
{
    public function __construct(private arrayKey,Value> $entries) {}

    public function set(Key $key, Value $value): self
    {
        $this->entries[$key] = $value;
        return $this;
    }
}

function f(Dictstring,string> $dict) {}

$dict = new Dict([1 => 'foo']);
$dict->set("foo", "bar"); // Static analyser error
$dict->set(1, "bar");     // Ok
f($dict);                 // Static analyser error

class StringList
{
    public function add(string $value)
    {
        $this->values[] = $value;
    }
}

class ListT>
{
    public function add(T $value)
    {
        $this->values[] = $value;
    }
}

$list = new StringList();
$list->add(123); // string型になる

$list = new Liststring>();
$list->add(123); // string型にならない

class A {}
class B extends A {}

function f(array $a) {}
function g(arrayA> $a) {}
function h(arrayB> $a) {}

$array = [new B()];

f($array);
g($array);
h($array);

$a = [1];       // array
$b = [new A()]; // array
$c = $b;        // array
$c[] = new B(); // array
$b;             // array

function f(arrayint> $a) {}

$a = [1];
f($a); // OK

$b = [new A()];
f($b); // エラー

$a = arrayint>(1); // array
$a[] = new A();     // エラー

function f(arrayint> $a) {}
function g(array $a) {}

$a = [1];

f($a); // OK
g($a); // エラー