semantic-typescript 0.7.0 → 0.8.0

package/readme.jp.md

@@ -1,38 +1,34 @@
-# Semantic-TypeScript
-フローにインデックスを。データを精密に制御。
+# **Semantic‑TypeScript**
+**ストリーム処理、インデックス化。** あなたのデータを精密に制御。
 
 ---
 
 ### 概要
 
-Semantic-TypeScriptは、JavaScriptの`GeneratorFunction`、Java Streams、MySQLスタイルのインデックスといった最も効果的な概念を統合し、ストリーム処理技術において大きな飛躍を遂げました。その中核にある哲学はシンプルかつ強力です。それは、力任せの反復処理ではなく、インテリジェントなインデックス付けを通じて、非常に効率的なデータ処理パイプラインを構築することです。
+Semantic‑TypeScriptは、ストリーム処理における重要な進化を表しており、JavaScriptジェネレーター、Java Streams、MySQLスタイルのインデックス作成から最も効果的なパラダイムを優雅に**統合**しています。その基本理念は強力かつ意図的です：従来の力任せの反復処理ではなく、インテリジェントなインデックス作成を通じて、非常に効率的なデータ処理パイプラインを構築します。
 
-従来のライブラリが同期的なループや扱いにくいPromiseチェーンを強いる場面で、Semantic-TypeScriptは、モダンなフロントエンド開発の要求に応える、完全非同期、関数型的に純粋、厳密なタイプセーフを備えた体験を提供します。
+従来のライブラリが同期ループや煩雑なPromiseチェーンを強いるのに対し、Semantic‑TypeScriptは、現代のアプリケーション開発の要求に特化して設計された、**完全非同期**、機能的に純粋、かつ厳密に型安全な体験を提供します。
 
-その洗練されたモデルでは、データは上流のパイプラインが明示的に`accept`（およびオプションで`interrupt`）コールバックを呼び出した時にのみ、コンシューマーに到達します。必要な**正確なタイミング**において、完全な制御をあなたが握ります。
+このモデルは洗練された制御フローを体現しています：データは、上流パイプラインが明示的に`accept`コールバックを呼び出す時だけ、下流のコンシューマーに渡されます。処理のタイミングについて、完全かつ細やかなコントロールを保持できます。処理は、必要とされる時、そしてその時にのみ正確に実行されます。
 
 ---
 
-### 開発者が選ぶ理由
+### 開発者がSemantic‑TypeScriptを選ぶ理由
 
-・**ボイラープレートなしのインデックス付け** — あらゆる要素が、自然または独自のインデックスを保持します。
-
-・**純粋関数型スタイル** — 完全なTypeScriptの型推論を伴います。
-
-・**リーク対策済みイベントストリーム** — `useWindow`、`useDocument`、`useHTMLElement`、`useWebSocket`は安全性を考慮して構築されています。`limit(n)`、`sub(start, end)`、`takeWhile(predicate)`を使って境界を定義すれば、ライブラリがクリーンアップを管理します。残存するリスナーもメモリリークもありません。
-
-・**組み込み統計機能** — 平均、中央値、最頻値、分散、歪度、尖度を含む、包括的な数値（`number`/`bigint`）分析。
-
-・**予測可能なパフォーマンス** — 要件に基づいて、順序付きまたは順序なしのコレクターを選択できます。
-
-・**メモリ効率** — ストリームは遅延評価されるため、メモリの懸念を軽減します。
-
-・**未定義動作なし** — TypeScriptが型安全性とnull安全性を保証します。入力データは、コールバック関数内で明示的に変更されない限り、変更されません。
+-   **ボイラープレート不要のインデックス作成** – 各要素は本来備わっている、またはカスタマイズされたインデックスを自然に保有し、手動での追跡を不要にします。
+-   **純粋関数型かつ型安全** – 不変な操作と共に、完全で慣用的なTypeScriptの型推論を享受できます。
+-   **メモリリーク防止のイベントストリーム** – `useSubscription`パターンは、リソースセキュリティを第一原則として設計されています。`limit(n)`、`sub(start, end)`、`takeWhile(predicate)`を使用して論理的な境界を定義するだけで、ライブラリが購読の完全なライフサイクルを管理します。これにより、残留リスナーやメモリリークは発生しません。
+-   **組み込み統計スイート** – 外部依存なしで、`number`および`bigint`ストリームに対する平均、中央値、最頻値、分散、歪度、尖度を含む包括的な分析機能にアクセスできます。
+-   **予測可能で調整可能なパフォーマンス** – 正確なパフォーマンスと順序要件に合わせて、順序付きまたは順序なしのコレクターを選択できます。
+-   **本質的にメモリ効率が良い** – ストリームは遅延評価され、メモリ負荷を軽減するため、要素はオンデマンドで処理されます。
+-   **未定義動作なし** – TypeScriptが完全な型安全性とnull安全性を保証します。コールバック関数内で明示的に変更しない限り、ソースデータは不変のままです。
 
 ---
 
 ### インストール
 
+お好みのパッケージマネージャーを使用して、プロジェクトにSemantic‑TypeScriptを統合します：
+
 ```bash
 npm install semantic-typescript
 ```
@@ -43,180 +39,229 @@ yarn add semantic-typescript
 
 ---
 
-### クイックスタート
+### 実践的な紹介
+
+以下の例は、基本的な変換から実際のイベント処理までの核心概念を示しています。
 
 ```typescript
-import { useOf, useFrom, useRange, useWindow, useHTMLElement, useWebSocket, useText, useStringify } from "semantic-typescript";
-
-// 数値の統計
-let summate: number = useOf(10, 20, 30, 40)
-  .map((n: number): number => n * 2)
-  .toNumericStatistics()  // 終端操作の前に必須
-  .summate();             // 200
-
-// Bigintの統計
-let summate: bigint = useOf(10n, 20n, 30n, 40n)
-  .map((n: bigint): bigint => n * 2)
-  .toBigIntStatistics()   // 終端操作の前に必須
-  .summate();             // 200n
-
-// インデックスでストリームを逆順に
-useFrom([1, 2, 3, 4, 5])
-  .redirect((element: E, index: bigint): bigint => -index) // 負のインデックスで逆順
-  .toOrdered() // toOrdered() を呼び出してインデックス順を維持
-  .toArray(); // [5, 4, 3, 2, 1]
-
-// ストリームをシャッフル
-useFrom([1, 2, 3, 4, 5])
-  .shuffle()
+import { useOf, useFrom, useRange, useSubscription, useText, useStringify } from "semantic-typescript";
+
+// ====================================================================
+// 例1: 基本的な操作と数値統計
+// ====================================================================
+// マッピング操作と終端統計操作を示します。変換後、パイプラインを統計コレクターに変換してから、`.summate()`などの終端メソッドを呼び出す必要があります。
+
+const numericSum: number = useOf(10, 20, 30, 40)
+  .map((n: number): number => n * 2)        // 各要素を2倍: [20, 40, 60, 80]
+  .toNumericStatistics()                    // 統計コレクターに変換
+  .summate();                               // 終端操作: 200
+
+// その他の統計メソッド（`.toNumericStatistics()`後に利用可能）:
+// .average(), .median(), .mode(), .variance(), .skewness(), .kurtosis()
+
+// ====================================================================
+// 例2: BigInt統計
+// ====================================================================
+// 数値統計と同様に動作しますが、BigIntデータ用に最適化されています。
+
+const bigintSum: bigint = useOf(10n, 20n, 30n, 40n)
+  .map((n: bigint): bigint => n * 2n)       // BigInt演算
+  .toBigIntStatistics()                     // BigInt統計コレクターに変換
+  .summate();                               // 終端操作: 200n
+
+// ====================================================================
+// 例3: ストリーム反転のためのインデックス操作
+// ====================================================================
+// `.redirect()`メソッドを使用して、要素のインデックスを戦略的に再割り当てすることで要素を並べ替える方法を示し、反転などのカスタムパターンを可能にします。
+
+const reversedArray: number[] = useFrom([1, 2, 3, 4, 5])
+  .redirect((_element: number, index: bigint): bigint => -index) // 負のインデックスにマッピング
+  .toOrdered()  // 必須: 新しいインデックスでソートされた要素を収集
+  .toArray();   // 結果: [5, 4, 3, 2, 1]
+
+// 単純な反転には、`.reverse()`も利用可能です。
+
+// ====================================================================
+// 例4: ストリームシャッフル
+// ====================================================================
+// インプレースシャッフルアルゴリズムを使用して、要素のインデックスをランダムに並べ替えます。
+
+const shuffledArray: number[] = useFrom([1, 2, 3, 4, 5])
+  .shuffle()      // インデックスをランダムに再割り当て
+  .toOrdered()    // 新しいランダムなインデックスでソート
+  .toArray();     // 例: [2, 5, 1, 4, 3] (実行ごとに異なる)
+
+// ====================================================================
+// 例5: ストリームの循環ローテーション
+// ====================================================================
+// 要素を循環的にシフトします。正の値は右回転、負の値は左回転です。
+
+// 右へ2ポジション回転
+const rightRotated: number[] = useFrom([1, 2, 3, 4, 5])
+  .translate(2)   // インデックスを右に2つシフト
   .toOrdered()
-  .toArray(); // 例: [2, 5, 1, 4, 3]
+  .toArray();     // 結果: [4, 5, 1, 2, 3]
 
-// ストリーム内の要素を平行移動
-useFrom([1, 2, 3, 4, 5])
-  .translate(2)  // 要素を2位置右にシフト
-  .toOrdered()
-  .toArray(); // [4, 5, 1, 2, 3]
+// ====================================================================
+// 例6: 無限範囲での遅延評価
+// ====================================================================
+// 理論的に無限のストリームを遅延的に処理し、必要な時だけ要素を計算します。
 
-useFrom([1, 2, 3, 4, 5])
-  .translate(-2) // 要素を2位置左にシフト
-  .toOrdered()
-  .toArray(); // [3, 4, 5, 1, 2]
+const firstTenMultiples: bigint[] = useRange(0n, 1_000_000n)
+  .filter(n => n % 17n === 0n)  // 17の倍数を保持
+  .limit(10n)                   // 重要: 10番目の一致後に停止
+  .toUnordered()                // ソートは不要
+  .toArray();                   // 結果: [0, 17, 34, 51, 68, 85, 102, 119, 136, 153]
 
-// 早期終了付きの無限レンジ
-useRange(0n, 1_000_000n)
-  .filter(n => n % 17n === 0n)
-  .limit(10n)          // 10要素で停止
-  .toUnordered()
+// `.limit(10n)`がなければ、パイプラインは100万要素すべてを処理します。
+
+// ====================================================================
+// 例7: 複雑なパイプラインの構築
+// ====================================================================
+// 複数の操作を順次組み合わせる方法を示します。
+
+const complexResult: number[] = useRange(1n, 100n)
+  .map(n => Number(n) * 2)
+  .filter(n => n > 50)
+  .shuffle()
+  .limit(5n)
+  .translate(2)
+  .toOrdered()
   .toArray();
 
-// リアルタイムウィンドウリサイズ (5イベント後に自動停止)
-useWindow("resize")
-  .limit(5n)          // イベントストリームでは重要
-  .toUnordered()
-  .forEach((ev, idx) => console.log(`リサイズ #${idx}`));
+// ====================================================================
+// 例8: 管理されたDOMイベント購読
+// ====================================================================
+// 自動的でメモリリーク防止のクリーンアップ機能付きで、ブラウザイベントを監視します。
+// `.limit(n)`の呼び出しは、リスナーの自動削除の境界を定義します。
+
+// Windowターゲット用のサブスクライバーを定義
+const windowSubscriber = {
+    mount: (target: Window): void => { /* セットアップロジック */ },
+    subscribe: (target: Window, event: keyof WindowEventMap, handler: EventListener): void => {
+        target.addEventListener(event, handler);
+    },
+    unsubscribe: (target: Window, event: keyof WindowEventMap, handler: EventListener): void => {
+        target.removeEventListener(event, handler);
+    },
+    unmount: (): void => { /* クリーンアップロジック */ }
+};
 
-// HTML要素のリスニング
-// <input id="input" type="text"/>
-useHTMLElement("#input", "change")
-  .limit(1)
+useSubscription(window, windowSubscriber, "resize")
+  .limit(5n) // 5イベント後に自動的に購読解除
   .toUnordered()
-  .forEach((event: Event) => submit(event));
+  .forEach((ev: Event, idx) =>
+    console.log(`リサイズ #${idx}: ${(ev.target as Window).innerWidth}x${(ev.target as Window).innerHeight}`)
+  );
 
-// 複数要素とイベントのリスニング
-useHTMLElement("input", ["change", "keyup"])
-  .takeWhile((event: Event): boolean => validate(event))
-  .toUnordered()
-  .forEach((event: Event) => submit(event));
-
-// WebSocketのリスニング
-let webSocket = new WebSocket("ws://localhost:8080");
-webSocket.addEventListener("close", (): void => {
-  webSocket.close();  // WebSocketのライフサイクルは手動で管理
-});
-useWebSocket(webSocket, "message")
-  .limit(1)
-  .toUnordered()
-  .forEach((message: MessageEvent) => console.log(message.data));
+// ====================================================================
+// 例9: Unicodeコードポイントによる文字列処理
+// ====================================================================
+// マルチバイトUnicode文字を正しく処理しながら、文字列を反復処理します。
 
-// 文字列をコードポイントでイテレート
 useText("My emotion now is: 😊, and semantic is 👍")
   .toUnordered()
-  .log(); // 文字列を出力
+  .log(); // 各文字（絵文字を含む）を改行して出力します。
+
+// ====================================================================
+// 例10: 循環参照を含むオブジェクトの安全な文字列化
+// ====================================================================
+// 循環参照を含むオブジェクトを安全にシリアライズします。
 
-// 循環参照を含むオブジェクトを安全に文字列化
-let o = {
+const obj = {
   a: 1,
-  b: "text",
-  c: [o.a, o.b, o.c] // 循環参照
+  b: "text"
 };
-// let text: string = JSON.stringify(o); // エラーをスロー
-let text: string = useStringify(o); // 安全に `{a: 1, b: "text", c: []}` を生成
+(obj as any).c = [obj.a, obj.b, (obj as any).c]; // 循環参照を導入
+
+// const text: string = JSON.stringify(obj); // エラーをスロー
+const text: string = useStringify(obj); // 安全に `{a: 1, b: "text", c: []}` を生成
 ```
 
 ---
 
-### コアコンセプト
+### 核心概念
 
-| 概念 | 目的 | 使用する場面 |
+| 概念 | 目的 | 主な使用例 |
 | :--- | :--- | :--- |
-| `AsynchronousSemantic` | 非同期ストリーム、イベント、遅延パイプラインのためのコアビルダー。 | リアルタイムイベント、WebSockets、DOMリスナー、長時間実行または無限ストリーム。 |
-| `SynchronousSemantic` | 同期、インメモリ、ループベースのストリームのビルダー。 | 静的なデータ、レンジ、即時イテレーション。 |
-| `toUnordered()` | 最速の終端コレクター（マップベースのインデックス付け）。 | パフォーマンスが重要なパス（O(n) 時間 & 空間、ソートなし）。 |
-| `toOrdered()` | ソート済み、インデックス安定のコレクター。 | 安定した順序付けまたはインデックス付きアクセスが必要な場合。 |
-| `toNumericStatistics()` | 豊富な数値統計分析（平均、中央値、分散、歪度、尖度など）。 | データ分析と統計計算。 |
-| `toBigIntStatistics()` | 豊富なbigint統計分析。 | 大きな整数に対するデータ分析と統計計算。 |
-| `toWindow()` | スライディングおよびタンブリングウィンドウのサポート。 | 時系列処理、バッチ処理、ウィンドウ操作。 |
+| `AsynchronousSemantic` | 非同期ストリーム、イベント、およびプッシュベースの遅延パイプラインのためのコアビルダー。 | リアルタイムイベント、WebSockets、DOMリスナー、または長時間実行/無限ストリーム。 |
+| `SynchronousSemantic` | 同期、メモリ内、またはプルベースの即時評価パイプラインのビルダー。 | 静的データ、有限範囲、または即時の反復処理タスク。 |
+| `toUnordered()` | 最速の終端コレクター。インデックス格納にMapを使用。 | 安定した順序が不要な性能重視のパス（時間・空間計算量 O(n)）。 |
+| `toOrdered()` | ソート済みでインデックスが安定した終端コレクター。 | 要素の順序を保持する必要がある場合、またはインデックスアクセスが必要な場合。 |
+| `toNumericStatistics()` | `number`ストリームでの豊富な統計分析を可能にするコレクター。 | データ分析、メトリクス、統計計算。 |
+| `toBigIntStatistics()` | `bigint`ストリームでの豊富な統計分析を可能にするコレクター。 | 大きな整数データセットの分析と統計。 |
+| `toWindow()` | ストリームに対するスライディングおよびタンブリングウィンドウ操作を提供。 | 時系列分析、バッチ処理、ウィンドウ集計。 |
 
 ---
 
-重要な使用ルール
+**必須の使用ルール**
 
-1.  イベントストリーム（`useWindow`、`useDocument`、`useHTMLElement`、`useWebSocket`、…）は `AsynchronousSemantic` を返します。
-    → リスニングを停止するには、`.limit(n)`、`.sub(start, end)`、または `.takeWhile()` を呼び出す**必須**です。そうしないと、リスナーはアクティブなままになります。
+1.  **イベントストリーム**（`useSubscription`などのファクトリー経由で作成）は`AsynchronousSemantic`を返します。
+    → リスナーを終了させるために、`.limit(n)`、`.sub(start, end)`、`.takeWhile(predicate)`などの境界定義メソッドを**必ず**呼び出す必要があります。そうしないと、購読がアクティブなままになります。
 
-2.  終端操作（`.toArray()`、`.count()`、`.average()`、`.reduce()`、`.findFirst()` など）は、コレクターに変換した後にのみ利用可能です：
+2.  **終端操作**（`.toArray()`、`.count()`、`.forEach()`、`.findFirst()`など）は、パイプラインをコレクターに変換した**後にのみ**利用可能です：
     ```typescript
-    .toUnordered()   // O(n) 時間 & 空間、ソートなし
+    .toUnordered()   // 最大速度のため、順序は保証されません。
     // または
-    .toOrdered()     // ソート済み、順序を維持
+    .toOrdered()     // 安定した、ソートされた出力のため。
+    // または
+    .toNumericStatistics() // 統計メソッドのため。
     ```
 
 ---
 
 ### パフォーマンス特性
 
-| コレクター | 時間計算量 | 空間計算量 | ソート済み？ | 最適な用途 |
+| コレクター | 時間計算量 | 空間計算量 | 順序保証？ | 理想的なシナリオ |
 | :--- | :--- | :--- | :--- | :--- |
-| `toUnordered()` | O(n) | O(n) | いいえ | 生の速度、順序が不要な場合。 |
-| `toOrdered()` | O(2n) | O(n) | はい | 安定した順序付け、インデックス付きアクセス、分析。 |
-| `toNumericStatistics()` | O(2n) | O(n) | はい | ソート済みデータを必要とする統計操作。 |
-| `toBigIntStatistics()` | O(2n) | O(n) | はい | bigintに対する統計操作。 |
-| `toWindow()` | O(2n) | O(n) | はい | 時間ベースのウィンドウ操作。 |
+| `toUnordered()` | O(n) | O(n) | いいえ | 生のスループットが鍵。最終的な順序は重要でない。 |
+| `toOrdered()` | O(n log n) | O(n) | はい（ソート済み） | 安定した順序、インデックスアクセス、または統計用の事前ソートが必要な場合。 |
+| `toNumericStatistics()` | O(n log n) | O(n) | はい（内部ソート） | ソートされたデータを必要とする統計操作の実行。 |
+| `toBigIntStatistics()` | O(n log n) | O(n) | はい（内部ソート） | BigIntデータでの統計操作。 |
+| `toWindow()` | O(n log n) | O(n) | はい（内部ソート） | ソートされたインデックスから恩恵を受けるウィンドウ操作。 |
 
-速度が最優先の場合は `toUnordered()` を選択してください。安定した順序付けやソート済みデータに依存する統計メソッドが必要な場合にのみ `toOrdered()` を使用してください。
+絶対的な速度が最重要である場合は`toUnordered()`を選択してください。ロジックが要素の順序に依存する場合にのみ、`toOrdered()`または統計コレクターを選択してください。
 
 ---
 
-他のフロントエンドストリームプロセッサとの比較
+**現代ストリームライブラリとの比較分析**
 
-| 特徴 | Semantic-TypeScript | RxJS | ネイティブ非同期イテレータ/ジェネレータ | Most.js |
+| 機能 | Semantic‑TypeScript | RxJS | ネイティブ Async Iterators / Generators | Most.js |
 | :--- | :--- | :--- | :--- | :--- |
-| **TypeScript統合** | 第一級、ネイティブなインデックス認識を伴う深い型付け。 | 優れているが、複雑なジェネリクスを伴う。 | 良好、手動での型付けが必要。 | 強い、関数型ファーストスタイル。 |
-| **組み込み統計分析** | `number` と `bigint` に対する包括的なネイティブサポート。 | ネイティブでは利用不可（カスタムオペレータが必要）。 | なし。 | なし。 |
-| **インデックス付け & 位置認識** | ネイティブ、あらゆる要素に対する強力なbigintインデックス付け。 | カスタムオペレータが必要（`scan`、`withLatestFrom`）。 | 手動のカウンタが必要。 | 基本的、組み込みインデックスなし。 |
-| **イベントストリーム管理** | 明示的な早期停止制御を備えた、専用の型安全ファクトリ。 | 強力だが、手動のサブスクリプション管理が必要。 | 手動イベントリスナー + キャンセル。 | 良好な `fromEvent`、軽量。 |
-| **パフォーマンス & メモリ効率** | 卓越 – 最適化された `toUnordered()` および `toOrdered()` コレクター。 | 非常に良好、だがオペレータチェーンはオーバーヘッドを加える。 | 卓越（オーバーヘッドゼロ）。 | 卓越。 |
-| **バンドルサイズ** | 非常に軽量。 | 大きい（ツリーシェイキング後も）。 | ゼロ（ネイティブ）。 | 小さい。 |
-| **API設計思想** | 明示的なインデックス付けを伴う関数型コレクターパターン。 | リアクティブObservableパターン。 | イテレータ/ジェネレータパターン。 | 関数型、ポイントフリー。 |
-| **早期終了 & 制御** | 明示的（`interrupt`、`.limit()`、`.takeWhile()`、`.sub()`）。 | 良好（`take`、`takeUntil`、`first`）。 | 手動（`for await…of` 内の `break`）。 | 良好（`take`、`until`）。 |
-| **同期 & 非同期サポート** | 統一されたAPI – 両方を第一級サポート。 | 主に非同期。 | 両方、だが手動。 | 主に非同期。 |
-| **学習曲線** | 関数型およびインデックス付きパイプラインに慣れた開発者にとって緩やか。 | 急（多くのオペレータ、hot/coldオブザーバブル）。 | 低い。 | 中程度。 |
-
-**Semantic-TypeScriptの主な利点**
-
-・   独自の組み込み統計およびインデックス機能により、手動での `reduce` や外部ライブラリが不要。
+| **TypeScript統合** | ファーストクラス、深い型付け、インデックス認識を内包。 | 優れているが、複雑なジェネリックチェーンを伴うことが多い。 | 良いが、手動の型注釈が必要。 | 強い、関数型ファーストの型付けスタイル。 |
+| **組み込み統計分析** | `number`および`bigint`に対する包括的なネイティブサポート。 | ネイティブでは利用不可（カスタムオペレーターまたは他のライブラリが必要）。 | なし。 | なし。 |
+| **インデックス作成と位置認識** | 各要素に対するネイティブで強力なBigIntインデックス作成。 | カスタムオペレーターが必要（例: `scan`、`withLatestFrom`）。 | 手動でのカウンター管理が必要。 | 基本的、組み込みのインデックスプロパティなし。 |
+| **イベントストリーム管理** | 明示的で宣言的なライフサイクル制御を備えた、型安全な専用ファクトリー。 | 強力だが、メモリリークを防ぐためには注意深い手動購読管理が必要。 | イベントリスナーの手動登録とキャンセルトークンの管理。 | 良い`fromEvent`、一般的に軽量。 |
+| **パフォーマンスとメモリ** | 卓越 – 最適化された`toUnordered()`および`toOrdered()`コレクターを提供。 | 非常に良いが、深いオペレーターチェーンはオーバーヘッドをもたらす可能性あり。 | 優れている（ネイティブオーバーヘッド最小限）。 | 優れている。 |
+| **バンドルサイズ** | 非常に軽量。 | 大きい（ツリーシェイキング後でも）。 | ゼロ（言語のネイティブ機能）。 | 小さい。 |
+| **API設計思想** | 明示的なインデックス意味論を持つ関数型コレクターパターン。 | リアクティブObservableパターン。 | 命令型Iterator / 宣言型Generatorパターン。 | 関数型、ポイントフリー構成。 |
+| **フロー制御** | 明示的（`interrupt`、`.limit()`、`.takeWhile()`、`.sub()`）。 | 良い（`take`、`takeUntil`、`first`）。 | 手動（ループ内の`break`）。 | 良い（`take`、`until`）。 |
+| **同期および非同期サポート** | 統一API – 両パラダイムに対するファーストクラスサポート。 | 主に非同期。 | 両方サポートされているが、手動ブリッジが必要。 | 主に非同期。 |
+| **学習曲線** | 関数型およびインデックス付きコレクションパイプラインに慣れた開発者には穏やか。 | 急（オペレーター語彙が広範、Hot/Cold Observable概念）。 | 低から中程度。 | 中程度。 |
 
-・   イベントストリームに対する明示的な制御により、RxJSで一般的なメモリリークを防止。
+**Semantic‑TypeScriptの利点**
 
-・   統一された同期/非同期設計により、多様なユースケースに対して単一で一貫したAPIを提供。
+*   **独自の能力：** 組み込みの統計およびインデックス作成機能により、手動の`reduce`操作や補助的なデータ分析ライブラリの必要性がなくなります。
+*   **予測可能なリソース管理：** イベントストリームに対する明示的な制御により、RxJSアプリケーションで発生しうる微妙なメモリリークを防止します。
+*   **統一された設計：** 同期および非同期ワークフロー両方の一貫したAPIにより、認知負荷とコード重複が減少します。
 
-この比較は、伝統的なリアクティブライブラリの煩雑さなしに、パフォーマンス、型安全性、豊富な分析機能を要求するモダンなTypeScriptフロントエンドアプリケーションに、Semantic-TypeScriptが特に適している理由を示しています。
+この比較は、従来のリアクティブフレームワークの複雑さなしに、高いパフォーマンス、堅牢な型安全性、および豊富なデータ処理機能を要求する現代のTypeScriptアプリケーションに、Semantic‑TypeScriptが特に適している理由を強調しています。
 
 ---
 
-### 探求を始めましょうか？
+### 探求を始めよう
 
-Semantic-TypeScriptは、複雑なデータフローを、読みやすく、合成可能で、高性能なパイプラインへと変えます。リアルタイムUIイベントの処理、大規模データセットの処理、分析ダッシュボードの構築のいずれにおいても、データベースレベルのインデックス付けの力を関数型プログラミングのエレガンスと共に提供します。
+Semantic‑TypeScriptは、複雑なデータフローを読みやすく、構成可能で、高性能なパイプラインに変換します。リアルタイムUIイベントの処理、大規模データセットの処理、分析ダッシュボードの構築のいずれにおいても、データベースレベルのインデックス作成のパワーと関数型プログラミングのエレガンスを提供します。
 
-次のステップ：
+**次のステップ：**
 
-・   IDE内で完全に型付けされたAPIを参照してください（すべてのエクスポートはメインパッケージから）。
+*   IDE内で直接、完全に型付けされたAPIを探索してください（すべてのエクスポートはメインパッケージエントリーポイントから利用可能です）。
+*   複雑な非同期イテレータやリアクティブチェーンを、明確で意図的なSemanticパイプラインに置き換えた開発者の成長するコミュニティに参加してください。
 
-・   複雑な非同期イテレータをクリーンなSemanticパイプラインに置き換えた開発者の成長するコミュニティに参加してください。
+**Semantic‑TypeScript** – ストリームと構造が出会う場所。
 
-Semantic-TypeScript — ストリームが構造と出会う場所。
+今日から構築を始め、考え抜かれたインデックス作成がもたらす明確な違いを体験してください。
 
-今日から構築を始め、考え抜かれたインデックス付けがもたらす違いを体験してください。
+**明確さをもって構築し、自信をもって前進し、意図をもってデータを変換する。**
 
-明確さをもって構築し、確信をもって進み、意図をもってデータを変革しましょう。
+MIT © Eloy Kim