Show HN: Katharos Python向け関数型プログラミングとCSPスタイルの並行処理
Show HN: Katharos Functional programming and CSP-style concurrency for Python (github.com)
要約
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 | ラップされた関数をラップされた値に適用する(<*>) |
>> | then | 2つのステップを順序付け、最初の値を破棄する |
@ | op | 2つの値を結合する(<>) |
@による結合
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を指定します。
ドキュメント
完全なチュートリアル、ハウツーガイド、APIリファレンス、および数学的基盤の説明は、katharos.readthedocs.io にあります。
ライセンス
MIT