HN 日本語サマリー

← 一覧へ戻る
プログラミング

Show HN: Katharos Python向け関数型プログラミングとCSPスタイルの並行処理

Show HN: Katharos Functional programming and CSP-style concurrency for Python (github.com)

24 pointsby kamalf7 コメント

要約

Katharosは、Python向けの関数型プログラミングと並行処理ライブラリです。代数的抽象化と具体的な型を、メッセージパッシング型の並行処理と組み合わせています。エラーや副作用、並行処理の通信を合成可能で型安全な値としてモデル化することで、例外処理やNoneチェックの代わりに、よりクリーンで宣言的なコードを実現します。GoスタイルのCSP並行処理もサポートしており、チャネルのクローズやタイムアウトも例外ではなく値として扱います。

全文翻訳

[画像: Katharos logo](https://github.com/kamalfarahani/katharos/blob/main/logo.png)

Pythonのための関数型プログラミングと並行処理ライブラリ。失敗したり、欠損値を返したりする可能性のある操作を連鎖させ、副作用の実行を制御し、型付けされたチャネルを通じて並行ワーカーを調整します。

[画像: PyPI](https://pypi.org/project/katharos/) [画像: Docs](https://katharos.readthedocs.io/en/latest/) [画像: License](https://opensource.org/licenses/MIT) [画像: Coverage](https://camo.githubusercontent.com/fe5c7e352b78254d38aeafcd25e0286a9a3385d27f38f1b5de145a181eaa63f7/68747470733a2f2f696d672e736869656c64732e696f2f62616467652f636f7665726167652d39342532352d627269676874677265656e)


インストール

Python 3.13+ が必要です。

pip install katharos

または uv を使用する場合:

uv add katharos

クイックスタート

例外を値に変換し、成功した結果を変換します:

from katharos.types import Result


@Result.catch(ValueError)
def parse_int(raw: str) -> int:
    return int(raw)


print(parse_int("21").fmap(lambda n: n * 2))
# Success(42)

print(parse_int("oops").fmap(lambda n: n * 2))
# Failure(ValueError("invalid literal for int() with base 10: 'oops'"))

成功した値はパイプラインを通過し続けます。失敗した場合は後続の変換をスキップします。Result.catch は宣言された例外タイプをキャッチし、そのトレースバックを保持します。

型階層

Katharosには2つの独立した階層があります。1つは計算の変換と連鎖のため、もう1つは値の結合のためです。各抽象化は上位のものに機能を追加します。具体的な型は両方に属することができます。

flowchart TD
    Functor --> Applicative --> Monad
    Semigroup --> Monoid
    Monad -.-> contexts["Maybe, Result, IO, Lazy"]
    Monad -.-> ImmutableList
    Monad -.-> NonEmptyList
    Monoid -.-> ImmutableList
    Semigroup -.-> NonEmptyList
    Monoid -.-> monoids["MonoidMaybe, Sum, Product"]

読み込み中

実線は継承を示し、点線は実装を示します。メソッドと法則については、型階層リファレンスを参照してください。

目標

Katharosは、関数型スタイルのPythonを実用的、安全、そして快適に書けるようにするために存在します。

  • エラー、不在、効果を値として。 Maybe、Result、IO、Lazy は、失敗、欠損データ、副作用を型シグネチャに配置し、それらをNoneや例外に隠すのではなく、そこで合成できるようにします。
  • 法則を遵守する抽象化。 Functor、Applicative、Monad、Semigroup、Monoid は代数的法則とともに提供され、プロパティベーステスト(Hypothesis)によってチェックされるため、リファクタリング時に信頼できます。
  • Pythonicなエルゴノミクス。 演算子(|、**、>>、@)とdo記法により、関数型コードはPython開発者にとって読みやすくなります。すべて完全に型注釈が付けられ、pyrightでチェックされます。
  • メッセージパッシング並行処理。 並行ワーカーを起動し、型付けされたチャネルを通じて通信します。チャネルの受信は、データ、クローズ、またはタイムアウトのためのResult値を返します。
  • 取り組みやすい。 チュートリアルが先行するため、有用なものを作成しながら一度に1つの概念を学習できます。
非目標
  • 完全なHaskellまたはScalaの型クラスエコシステムのポートではありません。Katharosは、小さく十分にテストされた抽象化のセットをカバーしています。
  • asyncioの代替ではありません。並行処理レイヤーはスレッドベースのメッセージパッシングです。

外観

2つの日常的な問題、それぞれKatharosなしの場合とありの場合を示します。

欠損値: Maybe

Katharosなしでは、すべてのルックアップに独自のNoneチェックが必要です:

def find_user(user_id: int) -> str | None:
    return {1: "ada", 2: "grace"}.get(user_id)


def find_discount(user: str) -> float | None:
    return {"ada": 0.15}.get(user)


def lookup_discount(user_id: int) -> float | None:
    user = find_user(user_id)  # str | None
    if user is None:
        return None
    return find_discount(user)


print(lookup_discount(1))  # 0.15
print(lookup_discount(2))  # None: no discount
print(lookup_discount(3))  # None: no user

Katharosを使用すると、find_userとfind_discountはMaybeを返し、do記法はNothingでショートサーキットします:

from katharos.types import Maybe
from katharos.syntax_sugar import do, DoBlock


def find_user(user_id: int) -> Maybe[str]:
    return Maybe.from_optional({1: "ada", 2: "grace"}.get(user_id))


def find_discount(user: str) -> Maybe[float]:
    return Maybe.from_optional({"ada": 0.15}.get(user))


@do(Maybe)
def lookup_discount(user_id: int) -> DoBlock[Maybe, float]:
    user: str = yield find_user(user_id)
    discount: float = yield find_discount(user)
    return discount


print(lookup_discount(1))  # Just(0.15)
print(lookup_discount(2))  # Nothing(): no discount
print(lookup_discount(3))  # Nothing(): no user
失敗: Result

Katharosなしでは、各ステップで例外が発生する可能性があるため、呼び出し元はどの例外をキャッチする必要があるかを知る必要があります:

def process(raw: str) -> int:
    n = int(raw)                              # may raise ValueError
    if n <= 0:
        raise ValueError(f"{n} is not positive")
    return n


print(process("42"))  # 42
try:
    process("0")
except ValueError as error:
    print(error)  # 0 is not positive

Katharosを使用すると、失敗は戻り値の型の一部となり、ステップは|で連鎖します:

from katharos.types import Result


@Result.catch(ValueError)
def parse_int(raw: str) -> int:
    return int(raw)


def validate_positive(n: int) -> Result[ValueError, int]:
    if n <= 0:
        return Result.Failure(ValueError(f"{n} is not positive"))
    return Result.Success(n)


def process(raw: str) -> Result[ValueError, int]:
    return parse_int(raw) | validate_positive


print(process("42"))  # Success(42)
print(process("0"))   # Failure(ValueError('0 is not positive'))
print(process("??"))  # Failure(ValueError("invalid literal for int() with base 10: '??'"))

型の概要

型用途
Maybe[A]欠損する可能性のある値: Just(value) または Nothing()
Result[E, A]失敗する可能性のある計算: Success(value) または Failure(error)
ImmutableList[T]値の変換、連鎖、結合のための不変リスト
NonEmptyList[T]少なくとも1つの要素が保証されているリスト
IO[A]明示的に.execute()で実行される遅延副作用
Lazy[A].resolve()で実行される遅延、メモ化された同期計算
Sum, Product数値を結合するための数値モナイド

型は抽象化に応じて演算子をサポートします:

演算子メソッド意味
``bind
**apラップされた関数をラップされた値に適用する(<*>)
>>then2つのステップを順序付け、最初の値を破棄する
@op2つの値を結合する(<>)

@による結合

Semigroup演算子は、同じ型の2つの値を結合します:

from katharos.types import ImmutableList

ImmutableList([1, 2]) @ ImmutableList([3, 4])  # ImmutableList([1, 2, 3, 4])

並行処理

KatharosはGoスタイルのメッセージパッシング並行処理を提供します。csp.goでワーカーを起動し、型付けされたチャネルを通じて通信します。recv()は、値、クローズエラー、またはタイムアウトエラーを含むResultを返します。

チャネル
from katharos.concurrency.csp import csp

ch = csp.Channel[int](capacity=1)

csp.go(ch.send, 42)     # Goの`go f(x)`のように、並行して作業を実行します

ch.recv()               # Success(42)

ch.close()
ch.recv()               # Failure(ChannelClosedError(...)): クローズは値であり、例外ではありません

チャネルのイテレーションは、チャネルが閉じられるまで値のシーケンスを返します。これはGo Tourのフィボナッチの例です。プロデューサーが値を送信してチャネルを閉じ、コンシューマーがそれを範囲で処理します。

from katharos.concurrency.csp import Channel, csp


def fibonacci(n: int, c: Channel[int]) -> None:
    x, y = 0, 1
    for _ in range(n):
        c.send(x)
        x, y = y, x + y
    c.close()


c = csp.Channel[int](capacity=10)
csp.go(fibonacci, 10, c)

for i in c:  # チャネルが閉じられるまで受信します
    print(i)  # 0 1 1 2 3 5 8 13 21 34
構造化並行処理

コンテキストマネージャーとして使用すると、goは、ブロックが終了する前に内部で起動されたすべての処理を結合するスコープになります:

from katharos.concurrency.csp import csp

def worker(n: int) -> None: ...

with csp.go:                 # スコープは内部で起動されたすべての処理を待ちます
    csp.go(worker, 1)
    csp.go(worker, 2)
# ここまでに両方のワーカーが完了しています
バックエンド

cspランタイムはデフォルトで標準のPythonスレッドを使用します。ワーカーの実行方法と同期方法をカスタマイズするには、別のBaseThreadingBackendを指定します。

ドキュメント

ここから始める: Katharos入門。

完全なチュートリアル、ハウツーガイド、APIリファレンス、および数学的基盤の説明は、katharos.readthedocs.io にあります。

ライセンス

MIT