Pythonで高カインド型を表現できない理由と回避策

高カインド型とは
高カインド型(higher-kinded type)とは、list[int]のintだけでなく、listに当たるコンテナの種類も型変数にするための概念である。
要素に関数を適用し、戻り値も元のコンテナの種類のままになるfmapのような関数の型を、1つのシグネチャで表現するために必要になる。
Pythonの型ヒントには高カインド型の構文がなく、型変数に型引数を指定すると、型チェッカーのmypyとpyrightの両方がエラーにする。
- 高カインド型がないと
listと自作のコンテナに対応するfmapの型を、1つのシグネチャでは正確に表現できない - 型変数
Fに対するF[A]は、mypyとpyrightのどちらでもエラーで、注釈を評価すると実行時もTypeErrorになる- Pythonの型変数は
listのように型引数が必要なものの代わりにならない - Python 3.12の型パラメータの構文でも同じである
- Pythonの型変数は
- この記事で比較する回避策は、対応するコンテナを列挙する
@overload、コンテナ側のメソッド、returnsライブラリのKindの3つである@overloadは列挙していないコンテナを引数にできない- returnsの
Kindはmypyのプラグインが前提で、pyrightでは要素の型がAnyになる
前提となるジェネリクスの概念
型コンストラクタ
型コンストラクタは型引数の指定で型を生成するものである(list、set、dictなど)。
以降の説明では要素の型を指定する前のlistと、指定した後のlist[int]を区別する。
T = TypeVar("T")のTの値はintやlist[int]だが、T[int]のように後から型引数を指定する対象にはならない。
kind
kindは型の種類で、型引数の個数と種類の組み合わせで区別される。
intやlist[int]のkindは*、型引数を1つ必要とするlistのkindは* -> *と表記する。
この記事の対象はkindが* -> *の型コンストラクタが型変数になる場合である。
TypeScriptとHigher Kinded Type では、* -> *より上の段階のkindもこの記法で説明している。
コンテナごとに別のシグネチャが必要になる
コード例のBoxは説明用に定義したクラスで、値を1つ保持する。
この節のBoxは空の状態(None)も保持できる。
class Box[A]やdef fmap[A, B]の構文を使用する例は、Python 3.12以降で動作する。
listとBoxの要素に関数を適用する関数は、次のように型ごとに定義することになる。
from collections.abc import Callable
from dataclasses import dataclass
from typing import Generic, TypeVar
A = TypeVar("A")
B = TypeVar("B")
@dataclass
class Box(Generic[A]):
value: A | None
def list_map(f: Callable[[A], B], xs: list[A]) -> list[B]:
return [f(x) for x in xs]
def box_map(f: Callable[[A], B], box: Box[A]) -> Box[B]:
return Box(None if box.value is None else f(box.value))
list_mapとbox_mapは、コンテナの引数と戻り値の型が、それぞれlistとBoxで異なる。
コンテナの種類を型変数Fにできれば、次の1つのシグネチャで両方を表現できる。
F = TypeVar("F")
def fmap(f: Callable[[A], B], fa: F[A]) -> F[B]:
raise NotImplementedError
# mypy
# error: Type variable "F" used with arguments [valid-type]
# pyright
# error: TypeVar "type[F@fmap]" is not subscriptable (reportGeneralTypeIssues)
このfmapのように、要素を変換してもコンテナの種類を維持する操作に対応したコンテナを、HaskellなどではFunctorと呼ぶ。
型変数に型引数を指定できない理由
型変数Fはkindが*の型の代わりになる変数なので、F[A]のように型引数を指定する対象にならない。
mypyはvalid-type、pyrightはreportGeneralTypeIssuesのエラーにする。
Pythonの型システムには、型変数のkindを* -> *と宣言する構文がない。
実行時も注釈を評価した時点でTypeError: 'typing.TypeVar' object is not subscriptableになる。
上のfmapは、Python 3.13以前では関数の定義の時点で注釈が評価されるので、定義そのものが失敗する。
Python 3.14以降は 注釈の評価が遅延される ので、定義は成功し、typing.get_type_hintsなどで注釈を評価した時点で失敗する。
PEP 695 の型パラメータの構文(Python 3.12以降)でも型チェッカーの診断は同一である。
def fmap[F, A, B](f: Callable[[A], B], fa: F[A]) -> F[B]:
raise NotImplementedError
# mypy
# error: Type variable "F" used with arguments [valid-type]
# pyright
# error: TypeVar "type[F@fmap]" is not subscriptable (reportGeneralTypeIssues)
型変数に型引数を指定できるようにする提案は、python/typingのissue で2018年から議論されていて、採用されたPEPはない。
Protocolを経由すると戻り値がProtocolの型になる
コンテナの種類を抽象化する別の方法は、mapメソッドを要求するProtocolである。
次のFunctorはmapの形だけを要求し、ListFはそれを実装する、説明のために定義したクラスである。
Protocolの判定の規則は PythonのProtocolと構造的部分型 で説明している。
from __future__ import annotations
from typing import Protocol, TypeVar, reveal_type
A = TypeVar("A", covariant=True)
B = TypeVar("B")
class Functor(Protocol[A]):
def map(self, f: Callable[[A], B]) -> Functor[B]: ...
class ListF(Functor[A]):
def __init__(self, values: list[A]) -> None:
self.values = values
def map(self, f: Callable[[A], B]) -> ListF[B]:
return ListF[B]([f(x) for x in self.values])
def list_only(self) -> list[A]:
return self.values
def abstract_map(fa: Functor[A], f: Callable[[A], B]) -> Functor[B]:
return fa.map(f)
mapped = ListF([1]).map(str)
reveal_type(mapped) # ListF[str]
mapped.list_only() # エラーにならない
abstracted = abstract_map(ListF([1]), str)
reveal_type(abstracted) # Functor[str]
abstracted.list_only()
# mypy
# error: "Functor[str]" has no attribute "list_only" [attr-defined]
# pyright
# error: Cannot access attribute "list_only" for class "Functor[str]"
ListFのmapを直接呼び出す場合は、戻り値の型にListF[B]を指定できるので、結果はListF[str]になる。
Functorを引数とするabstract_mapを経由すると、戻り値の型の指定はFunctor[B]が限界で、結果はFunctor[str]になる。
実行時の値はListFだが、型チェッカーはListFに固有のメソッドの呼び出しをエラーにする。
abstract_mapの戻り値を引数と同じコンテナの型にするにはF[B]の記述が必要で、これが高カインド型である。
typing.Selfも代わりにならない。
Selfは自身のクラスの型を意味するが、型引数を指定できない。
from typing import Self
class Box[A]:
def changing_map[B](self, f: Callable[[A], B]) -> Self[B]: ...
# mypy
# error: Self type cannot have type arguments [misc]
# pyright
# error: Expected no type arguments for class "Self" (reportInvalidTypeArguments)
Selfを戻り値にしたメソッドでは型引数を変更できず、上のBoxの例ではBox[int]のmapの結果は常にBox[int]になる。
回避策
対応するコンテナを@overloadで列挙する
対応するコンテナが限られていれば、@overloadでコンテナごとのシグネチャを列挙できる。
from typing import overload
@overload
def fmap[A, B](f: Callable[[A], B], fa: list[A]) -> list[B]: ...
@overload
def fmap[A, B](f: Callable[[A], B], fa: Box[A]) -> Box[B]: ...
def fmap[A, B](f: Callable[[A], B], fa: list[A] | Box[A]) -> list[B] | Box[B]:
if isinstance(fa, list):
return [f(x) for x in fa]
return Box(None if fa.value is None else f(fa.value))
reveal_type(fmap(str, [1])) # list[str]
reveal_type(fmap(str, Box(1))) # Box[str]
呼び出し側では戻り値の型が元のコンテナの型になる。
ただし列挙していないコンテナは引数にできず、コンテナを追加するたびにfmapの定義の変更が必要になる。
変換をコンテナのメソッドにする
コンテナ自身にmapメソッドを定義すれば、戻り値の型に同一のクラスを指定できる。
from __future__ import annotations
@dataclass
class Box[A]:
value: A | None
def map[B](self, f: Callable[[A], B]) -> Box[B]:
return Box(None if self.value is None else f(self.value))
reveal_type(Box(1).map(str)) # Box[str]
Boxのクラスの定義の中では、Boxを型コンストラクタとして参照できるので、Box[B]を記述できる。
一方で、mapを定義した複数の種類のコンテナを引数とし、戻り値が引数と同一の種類のコンテナになる関数は、この方法でも定義できない。
その関数の引数の型は前節のProtocolになり、戻り値の型もFunctor[B]になるからである。
returnsのKindで型コンストラクタを型引数にする
returns ライブラリは、F[A]をKind1[F, A]と表記するエンコーディングを提供する。
F自体を型引数の1つとして指定するので、型変数に型引数を指定する構文は不要である。
コンテナはSupportsKind1を継承し、関数は引数と戻り値をKind1で宣言し、結果はdekindで元のコンテナの型に変換する。
from __future__ import annotations
from typing import Any, Generic, TypeVar
from returns.interfaces.mappable import Mappable1
from returns.io import IO
from returns.primitives.hkt import Kind1, SupportsKind1, dekind
A = TypeVar("A")
B = TypeVar("B")
class Box(SupportsKind1["Box[Any]", A], Mappable1[A], Generic[A]):
def __init__(self, value: A) -> None:
self.value = value
def map(self, function: Callable[[A], B]) -> Box[B]:
return Box(function(self.value))
F = TypeVar("F", bound=Mappable1[Any])
def fmap(f: Callable[[A], B], fa: Kind1[F, A]) -> Kind1[F, B]:
return fa.map(f)
reveal_type(dekind(fmap(str, Box(1)))) # mypy: Box[str]
reveal_type(dekind(fmap(str, IO(1)))) # mypy: IO[str]
Kind1の型引数の対応はreturnsの mypyプラグイン が解決するので、mypyの設定でプラグインを有効にする。
# pyproject.toml
[tool.mypy]
plugins = ["returns.contrib.mypy.returns_plugin"]
型チェッカーごとのdekind(fmap(str, Box(1)))の型は次のとおりである。
| 型チェッカー | 推論結果 |
|---|---|
| mypy(returnsのプラグインあり) | Box[str] |
| mypy(プラグインなし) | Box[Any] |
| pyright | Box[Any] |
プラグインがない場合の要素の型はstrではなくAnyになる。
pyrightでも結果はBox[Any]で、この方法では変換後の要素の型strを保持できない。
引数にできるのはSupportsKind1とMappable1に対応したコンテナだけで、listはそのままでは引数にできない。
他の言語での高カインド型
| 言語 | 高カインド型の書き方 | 備考 |
|---|---|---|
| Haskell | class Functor f where fmap :: (a -> b) -> f a -> f b |
型変数のkindは推論で* -> *になる |
| Scala | trait Functor[F[_]] |
F[_]で、型引数が1つの型コンストラクタを宣言する |
| TypeScript | 構文なし | fp-tsは型コンストラクタを文字列の識別子に対応させるエンコーディングを採用している |
| Python | 構文なし | returnsのKindはfp-tsと同じ系統のエンコーディングで、mypyのプラグインが前提 |
回避策の使い分け
| 状況 | 選択する方法 | 理由 |
|---|---|---|
| 対応するコンテナが少数で固定 | @overload |
標準の型ヒントのみで、mypyとpyrightの両方で戻り値の型が元のコンテナになる |
| 変換を自作のコンテナにのみ提供する | コンテナのメソッド | 戻り値の型に同一のクラスを指定できる |
| returnsのインターフェースに対応させたコンテナを抽象化し、型チェッカーはmypyのみ | returnsのKind |
mypyのプラグインで戻り値の型が元のコンテナになる |
mapを実装したコンテナを抽象化し、戻り値のコンテナに固有の操作は不要 |
Protocol | 戻り値の型はProtocolの型になるが、標準の型ヒントのみでmypyとpyrightの両方に対応する |


