本文へスキップ

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

python-higher-kinded-type

高カインド型とは

高カインド型(higher-kinded type)とは、list[int]のintだけでなく、listに当たるコンテナの種類も型変数にするための概念である。
要素に関数を適用し、戻り値も元のコンテナの種類のままになるfmapのような関数の型を、1つのシグネチャで表現するために必要になる。
Pythonの型ヒントには高カインド型の構文がなく、型変数に型引数を指定すると、型チェッカーのmypyとpyrightの両方がエラーにする。

  • 高カインド型がないとlistと自作のコンテナに対応するfmapの型を、1つのシグネチャでは正確に表現できない
    • コンテナごとに別のシグネチャが必要になる
    • Protocolを経由すると、戻り値の型が元のコンテナではなくProtocolの型になる
  • 型変数Fに対するF[A]は、mypyとpyrightのどちらでもエラーで、注釈を評価すると実行時もTypeErrorになる
    • Pythonの型変数はlistのように型引数が必要なものの代わりにならない
    • Python 3.12の型パラメータの構文でも同じである
  • この記事で比較する回避策は、対応するコンテナを列挙する@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の両方に対応する

この記事に出てくる用語

用語集の一覧へ

関連事例

  • データ分析支援

    事例:過去実績を提案に活用する分析の仕組み

    広告代理店との取り組みです。同社は過去実績の示唆を次の提案へ反映し、結果をどのように予測したか、その背景まで提案先のクライアントへ説明できるようになりました。KDOT は案ごとの見込みと判断材料を比較できる仕組みを業務アプリとして実装しました。さらに業務アプリの中核となる処理ロジックと機械学習モデルについて、特許手続きを担う弁理士が技術の新規性や工夫を検討するための資料を作成しました。その後この発明には特許が付与されました。

  • データ基盤構築 / 技術顧問(技術企業向け)

    事例:効果検証の分析処理基盤

    効果検証を提供する分析会社との取り組みです。同社は分析者の人数に比例してしか売上と利益を伸ばせない事業の形を、効果検証をプロダクトとして提供することで変革しようとしていました。手法とモデルは同社のまま、社内では開発できなかった、データと機械学習の重い推定を製品として動かす仕組みの開発を、開発支援会社の KDOT に任せました。推定を案件ごとの手作業ではなくシステムで実行できるようになったことで、同社は人数に比例しない形で売上と利益を伸ばすことを目指せるようになりました。

お問い合わせ・ご相談

システム開発、データ活用、プロダクトづくりのことならお気軽にご相談ください。要件が固まる前の整理や、お見積もりだけのご依頼も承ります。