semantic-typescript 0.6.0 → 0.7.0

package/readme.jp.md

@@ -1,204 +1,222 @@
-# Semantic-TypeScript: パラダイムを転換するストリーム処理ライブラリ
+# Semantic-TypeScript
+フローにインデックスを。データを精密に制御。
 
-## はじめに
-Semantic-TypeScriptは、ストリーム処理技術における大きな進歩を表しており、JavaScriptのジェネレーター関数、Javaストリーム、およびデータベースのインデックス作成パラダイムから最も効果的な概念を統合しています。その基本的な設計原則は、洗練された遅延評価とインテリジェントなインデックス作成を通じて、非常に効率的なデータ処理パイプラインを構築することに焦点を当てています。このライブラリは、現代のTypeScriptおよびJavaScript開発向けに特別に設計された、厳密に型安全で関数型的に純粋なストリーミング操作体験を提供します。
+---
 
-従来の同期処理アーキテクチャとは対照的に、Semantic-TypeScriptは同期（Iterable）と非同期（AsyncIterable）の両方のデータソースを優雅に扱う統一モデルを実装しています。ストリーム生成中、データの流れと終了はコールバックメカニズムによって正確に制御され、これにより、ライブラリは例外的な優雅さを持って以下の処理を可能にします：
-- 確定的な制御を伴うリアルタイムデータストリーム（DOMイベント、WebSocket、インターバル）
-- メモリ効率の良い遅延パイプラインによる大規模データセット
-- 流暢で宣言的なAPIによる複雑なデータ変換
+### 概要
 
-このライブラリの革新的なアプローチは、開発者がデータのシーケンスとどのように対話するかを根本的に再構想し、単一のまとまりのあるパッケージの中で、前例のないパフォーマンス特性と開発者の人間工学の両方を提供します。
+Semantic-TypeScriptは、JavaScriptの`GeneratorFunction`、Java Streams、MySQLスタイルのインデックスといった最も効果的な概念を統合し、ストリーム処理技術において大きな飛躍を遂げました。その中核にある哲学はシンプルかつ強力です。それは、力任せの反復処理ではなく、インテリジェントなインデックス付けを通じて、非常に効率的なデータ処理パイプラインを構築することです。
 
-## コア哲学：定義と実行の分離
-Semantic-TypeScriptの主要なアーキテクチャ的洞察は、ストリームの定義とその実行の明確な分離です：
-- **Semantic<E>**: データ変換パイプラインの不変で遅延的な青写真。どのような操作（フィルター、マップなど）が実行されるかを定義します。
-- **Collectable<E>**: ストリームの実体化された実行可能なビュー。Semanticから取得され、パイプラインを実行して結果を生成するためのすべての終端操作（collect、forEachなど）を提供します。
+従来のライブラリが同期的なループや扱いにくいPromiseチェーンを強いる場面で、Semantic-TypeScriptは、モダンなフロントエンド開発の要求に応える、完全非同期、関数型的に純粋、厳密なタイプセーフを備えた体験を提供します。
 
-この分離は明確なメンタルモデルを強制し、最大速度のために不要なソートをスキップするためにUnorderedCollectableを選択するなどの強力な最適化を可能にします。
+その洗練されたモデルでは、データは上流のパイプラインが明示的に`accept`（およびオプションで`interrupt`）コールバックを呼び出した時にのみ、コンシューマーに到達します。必要な**正確なタイミング**において、完全な制御をあなたが握ります。
 
-## なぜSemantic-TypeScriptを選ぶのか？
-データストリーム処理に適切なライブラリを選択することは、パフォーマンス、型安全性、表現力のバランスを取ることを伴います。Semantic-TypeScriptは、これらすべての次元で優れるように設計されています。
+---
 
-### 1. すべてのデータシーケンスのための統一された型安全パラダイム
-静的配列、リアルタイムイベント、非同期チャンクなど、あらゆるデータシーケンスを処理するための一貫した宣言的APIを提供し、エンドツーエンドの型安全性を確保するためにTypeScriptの完全な力を活用します。これにより、ランタイムエラーの全クラスを排除し、ストリーム操作を予測可能でコンパイラ検証済みのアクティビティに変えます。
+### 開発者が選ぶ理由
 
-### 2. インテリジェントな遅延性による妥協のないパフォーマンス
-中核的には、このライブラリは遅延評価に基づいて構築されています。フィルター、マップ、flatMapなどの操作は単に処理パイプラインを構成するだけで、終端操作が呼び出されるまで実際の作業は行われません。これは、limit、anyMatch、またはカスタム中断コールバックを介した短絡評価機能と組み合わされ、処理を早期に停止させ、大規模または無限のストリームの効率を劇的に向上させます。
+・**ボイラープレートなしのインデックス付け** — あらゆる要素が、自然または独自のインデックスを保持します。
 
-### 3. `Collector<E, A, R>` パターンの力
-Javaに触発され、Collectorパターンは柔軟性のエンジンです。これは、ストリーム要素をどのように累積するかの仕様を、ストリーム自体の実行から分離します。ライブラリは日常業務のための豊富な組み込みコレクタ（toArray、groupBy、summateなど）を提供する一方、独自の複雑で再利用可能なリダクションロジックを実装することを簡単にします。これは、固定された終端メソッドのセットよりもはるかに強力で合成可能です。
+・**純粋関数型スタイル** — 完全なTypeScriptの型推論を伴います。
 
-### 4. 現代のWebおよび非同期データへの第一級サポート
-Semantic-TypeScriptは、現代の開発のために設計されています。現代のWebソースに対するネイティブのファクトリメソッドを提供します：
-- 静的データのための `useFrom(iterable)`, `useRange()`
-- 時間ベースのストリームのための `useInterval()`, `useAnimationFrame()`
-- チャンク化されたバイナリデータ処理のための `useBlob()`
-- リアルタイムイベントストリームのための `useWebSocket()`, `useDocument()`, `useWindow()`
+・**リーク対策済みイベントストリーム** — `useWindow`、`useDocument`、`useHTMLElement`、`useWebSocket`は安全性を考慮して構築されています。`limit(n)`、`sub(start, end)`、`takeWhile(predicate)`を使って境界を定義すれば、ライブラリがクリーンアップを管理します。残存するリスナーもメモリリークもありません。
 
-### 5. 基本的な集計を超えて：組み込み統計分析
-単純な合計や平均を超えてください。このライブラリは専用のNumericStatisticsおよびBigIntStatisticsインターフェースを提供し、分散、標準偏差、中央値、歪度、尖度などの高度な統計尺度にストリームから直接アクセスできるようにします。これにより、複雑なデータ分析がワンライナーに変わります。
+・**組み込み統計機能** — 平均、中央値、最頻値、分散、歪度、尖度を含む、包括的な数値（`number`/`bigint`）分析。
 
-### 6. 開発者の人間工学のために設計
-- **流暢で連鎖可能なAPI**: 複雑なデータパイプラインを読みやすい連続的なチェーンとして記述できます。
-- **包括的なユーティリティスイート**: 必須のガード（isFunction、isIterable）、ユーティリティ（useCompare、useTraverse）、および関数型インターフェースが含まれています。
-- **Optional<T> 統合**: 値の不在を安全にモデル化し、nullポインタの懸念を排除します。
-- **パフォーマンスガイダンス**: 速度のために順序なしコレクションを使用するタイミングと、シーケンスのために順序ありを使用するタイミングに関する明確なガイダンス。
+・**予測可能なパフォーマンス** — 要件に基づいて、順序付きまたは順序なしのコレクターを選択できます。
 
-## インストール
-```bash
-npm install semantic-typescript
-```
+・**メモリ効率** — ストリームは遅延評価されるため、メモリの懸念を軽減します。
 
-## 実践におけるコアコンセプト
+・**未定義動作なし** — TypeScriptが型安全性とnull安全性を保証します。入力データは、コールバック関数内で明示的に変更されない限り、変更されません。
 
-### 1. ストリームの作成（Semantic）
-ファクトリ関数を使用してさまざまなソースからストリームを作成できます。
-```typescript
-import { useFrom, useInterval, useDocument } from 'semantic-typescript';
-
-// 静的配列から
-const staticStream = useFrom([1, 2, 3, 4, 5]);
-
-// 非同期ジェネレーターから
-const asyncStream = useFrom(async function*() {
-  yield 1;
-  yield 2;
-});
+---
 
-// 時間ベースのストリーム
-const tickStream = useInterval(1000); // 毎秒発行
+### インストール
 
-// DOMイベントストリーム（以下の重要な注意点を参照）
-const clickStream = useDocument('click');
+```bash
+npm install semantic-typescript
 ```
-
-### 2. ストリームの変換（中間操作）
-操作は遅延的に連鎖してパイプラインを定義します。
-```typescript
-const processedStream = staticStream
-  .filter(x => x % 2 === 0) // 偶数だけを保持
-  .map(x => x * 10) // 10倍
-  .flatMap(x => [x, x + 1]) // 各要素を2つに変換
-  .distinct(); // 重複を削除
-// まだ何も実行されていません
+または
+```bash
+yarn add semantic-typescript
 ```
 
-### 3. ストリームの実行（終端操作）
-結果を得るには、Collectableを取得し、終端操作を呼び出す必要があります。
-```typescript
-// パフォーマンスのために順序なしcollectableを取得
-const resultArray = await processedStream.toUnordered().toArray();
-console.log(resultArray); // 例: [20, 21, 40, 41]
-
-// 組み込みコレクタを使用
-const sum = await processedStream.toUnordered().collect(useSummate());
-console.log(sum);
-
-// または汎用collectメソッドを使用
-const customResult = await processedStream.toOrdered().collect(
-  () => new Map<number, number>(),
-  (map, element, index) => map.set(index, element),
-  map => map
-);
-```
+---
 
-### 4. 重要：イベントストリームの操作
-イベントストリーム（useDocument、useWindow、useHTMLElement、useWebSocket）は本質的に無限です。イベントの収集を停止してストリームを完了するタイミングを定義するために、sub、takeWhile、limitなどの操作を使用する必要があります。そうしないと、終端操作は無期限に待機します。
-```typescript
-import { useDocument } from 'semantic-typescript';
+### クイックスタート
 
-// 最初の5回のクリックだけを収集
-const first5Clicks = await useDocument('click')
-  .limit(5) // <- 必須：ストリームを5つのイベントに制限
+```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()
+  .toOrdered()
+  .toArray(); // 例: [2, 5, 1, 4, 3]
+
+// ストリーム内の要素を平行移動
+useFrom([1, 2, 3, 4, 5])
+  .translate(2)  // 要素を2位置右にシフト
+  .toOrdered()
+  .toArray(); // [4, 5, 1, 2, 3]
+
+useFrom([1, 2, 3, 4, 5])
+  .translate(-2) // 要素を2位置左にシフト
+  .toOrdered()
+  .toArray(); // [3, 4, 5, 1, 2]
+
+// 早期終了付きの無限レンジ
+useRange(0n, 1_000_000n)
+  .filter(n => n % 17n === 0n)
+  .limit(10n)          // 10要素で停止
   .toUnordered()
   .toArray();
 
-// 10秒間のクリックを収集
-const clicksIn10s = await useDocument('click')
-  .takeWhile((_, index, startTime = Date.now()) => Date.now() - startTime < 10000)
+// リアルタイムウィンドウリサイズ (5イベント後に自動停止)
+useWindow("resize")
+  .limit(5n)          // イベントストリームでは重要
   .toUnordered()
-  .toArray();
+  .forEach((ev, idx) => console.log(`リサイズ #${idx}`));
 
-// インデックス2から5（0ベース）のクリックを収集
-const specificClicks = await useDocument('click')
-  .sub(2n, 6n) // <- インデックス2、3、4、5の要素を取得
+// HTML要素のリスニング
+// <input id="input" type="text"/>
+useHTMLElement("#input", "change")
+  .limit(1)
   .toUnordered()
-  .toArray();
-```
+  .forEach((event: Event) => submit(event));
 
-**重要な洞察**: イベント（例：MouseEvent）とその連続的な発火インデックス（bigintとして）は、`accept(event, index)`コールバックを介してパイプラインを通して一緒に渡されます。
+// 複数要素とイベントのリスニング
+useHTMLElement("input", ["change", "keyup"])
+  .takeWhile((event: Event): boolean => validate(event))
+  .toUnordered()
+  .forEach((event: Event) => submit(event));
 
-### 5. 統計の活用
-```typescript
-const numericStream = useFrom([10, 20, 30, 40, 50]).toNumeric();
-const average = await numericStream.average();
-const median = await numericStream.median();
-const standardDeviation = await numericStream.standardDeviation();
-const skewness = await numericStream.skewness();
-console.log(`平均: ${average}, 中央値: ${median}, 標準偏差: ${standardDeviation}`);
-```
+// 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));
 
-## 主な機能
-- **デュアルストリームタイプ**: 同期（Iterable用）と非同期（AsyncIterableとイベント用）の両方のフルサポート
-- **豊富な操作セット**: filter, map, flatMap, concat, distinct, sorted, limit, skip, peek, reverse, shuffle
-- **柔軟な終端操作**: collect（カスタムコレクタ付き）, toArray, toSet, toMap, forEach, reduce, findFirst, anyMatch, allMatch, count
-- **高度なコレクタ**: 連結、グループ化、分割、合計、平均、最大値、最小値のための組み込みコレクタ
-- **統計モジュール**: 数値/ bigintストリームに対する平均、中央値、最頻値、分散、標準偏差、範囲、分位数、歪度、尖度のためのすぐに使えるメソッド
-- **ユーティリティ関数**: 型ガード（isPromise、isAsyncIterable）、コンパレータ（useCompare）、トラバーサル（useTraverse）、変換フック
-- **Optional<T>**: null許容値のためのモナディックコンテナ。検索操作と統合されています。
-
-## API概要
-### コアクラス＆インターフェース
-- `Semantic<E>` / `AsynchronousSemantic<E>`: 抽象ストリーム定義
-- `Collectable<E>` / `AsynchronousCollectable<E>`: 終端操作を持つ実行可能ストリーム
-- `OrderedCollectable<E>` / `UnorderedCollectable<E>`: 順序に敏感または順序に敏感でない操作に最適化された実体化バージョン
-- `Collector<E, A, R>`: 可変リダクション操作の抽象化
-
-### ファクトリ関数（use*）
-- **ソースから**: useFrom, useRange, useFill, useEmpty
-- **時間から**: useInterval, useAnimationFrame
-- **Web APIから**: useBlob, useDocument, useWindow, useHTMLElement, useWebSocket
-- **コレクタ**: useToArray, useGroupBy, useSummate, useJoin など
-
-## パフォーマンスに関する注意点
-- **遅延評価**: パイプラインは、終端操作が呼び出されるまで実行されずに構成されます
-- **短絡評価**: limit、anyMatch、findFirstなどの操作は、結果が決定するとすぐに要素の処理を停止します
-- **順序あり vs 順序なし**:
-    - ソース要素の順序が結果に影響しない終端操作（例：合計、最大値、またはtoSet）の場合、`.toUnordered()`を使用します。これにより、高価なソートステップをスキップする内部最適化が可能になる場合があります
-    - シーケンスが重要な場合（例：順序を保持する必要があるtoArray）には、`.toOrdered()`を使用します
-
-## はじめの一歩の例
-```typescript
-import { useFrom, useSummate, useGroupBy } from 'semantic-typescript';
-
-interface Transaction {
-  id: number;
-  amount: number;
-  category: string;
-}
-
-const transactions: Transaction[] = [
-  { id: 1, amount: 100, category: 'Food' },
-  { id: 2, amount: 200, category: 'Electronics' },
-  { id: 3, amount: 50, category: 'Food' },
-  { id: 4, amount: 300, category: 'Electronics' },
-];
-
-// カテゴリごとの合計金額を計算
-const totalsByCategory = await useFrom(transactions)
+// 文字列をコードポイントでイテレート
+useText("My emotion now is: 😊, and semantic is 👍")
   .toUnordered()
-  .collect(
-    useGroupBy(
-      t => t.category,
-      t => t.amount,
-      useSummate() // 値のためのコレクタ
-    )
-  );
-
-console.log(totalsByCategory); // Map { 'Food' => 150, 'Electronics' => 500 }
+  .log(); // 文字列を出力
+
+// 循環参照を含むオブジェクトを安全に文字列化
+let o = {
+  a: 1,
+  b: "text",
+  c: [o.a, o.b, o.c] // 循環参照
+};
+// let text: string = JSON.stringify(o); // エラーをスロー
+let text: string = useStringify(o); // 安全に `{a: 1, b: "text", c: []}` を生成
 ```
 
-Semantic-TypeScriptは、厳密に設計された、型安全で高性能なストリーム処理ライブラリを求める開発者のために構築されています。これは、エンタープライズレベルのデータ変換パターンの力をTypeScriptエコシステムにもたらし、データ集約型のフロントエンドアプリケーション、Node.jsデータ処理、シーケンスのエレガントで効率的な処理が必要とされるあらゆるシナリオに最適です。
+---
+
+### コアコンセプト
+
+| 概念 | 目的 | 使用する場面 |
+| :--- | :--- | :--- |
+| `AsynchronousSemantic` | 非同期ストリーム、イベント、遅延パイプラインのためのコアビルダー。 | リアルタイムイベント、WebSockets、DOMリスナー、長時間実行または無限ストリーム。 |
+| `SynchronousSemantic` | 同期、インメモリ、ループベースのストリームのビルダー。 | 静的なデータ、レンジ、即時イテレーション。 |
+| `toUnordered()` | 最速の終端コレクター（マップベースのインデックス付け）。 | パフォーマンスが重要なパス（O(n) 時間 & 空間、ソートなし）。 |
+| `toOrdered()` | ソート済み、インデックス安定のコレクター。 | 安定した順序付けまたはインデックス付きアクセスが必要な場合。 |
+| `toNumericStatistics()` | 豊富な数値統計分析（平均、中央値、分散、歪度、尖度など）。 | データ分析と統計計算。 |
+| `toBigIntStatistics()` | 豊富なbigint統計分析。 | 大きな整数に対するデータ分析と統計計算。 |
+| `toWindow()` | スライディングおよびタンブリングウィンドウのサポート。 | 時系列処理、バッチ処理、ウィンドウ操作。 |
+
+---
+
+重要な使用ルール
+
+1.  イベントストリーム（`useWindow`、`useDocument`、`useHTMLElement`、`useWebSocket`、…）は `AsynchronousSemantic` を返します。
+    → リスニングを停止するには、`.limit(n)`、`.sub(start, end)`、または `.takeWhile()` を呼び出す**必須**です。そうしないと、リスナーはアクティブなままになります。
+
+2.  終端操作（`.toArray()`、`.count()`、`.average()`、`.reduce()`、`.findFirst()` など）は、コレクターに変換した後にのみ利用可能です：
+    ```typescript
+    .toUnordered()   // O(n) 時間 & 空間、ソートなし
+    // または
+    .toOrdered()     // ソート済み、順序を維持
+    ```
+
+---
+
+### パフォーマンス特性
+
+| コレクター | 時間計算量 | 空間計算量 | ソート済み？ | 最適な用途 |
+| :--- | :--- | :--- | :--- | :--- |
+| `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()` を選択してください。安定した順序付けやソート済みデータに依存する統計メソッドが必要な場合にのみ `toOrdered()` を使用してください。
+
+---
+
+他のフロントエンドストリームプロセッサとの比較
+
+| 特徴 | Semantic-TypeScript | RxJS | ネイティブ非同期イテレータ/ジェネレータ | 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` や外部ライブラリが不要。
+
+・   イベントストリームに対する明示的な制御により、RxJSで一般的なメモリリークを防止。
+
+・   統一された同期/非同期設計により、多様なユースケースに対して単一で一貫したAPIを提供。
+
+この比較は、伝統的なリアクティブライブラリの煩雑さなしに、パフォーマンス、型安全性、豊富な分析機能を要求するモダンなTypeScriptフロントエンドアプリケーションに、Semantic-TypeScriptが特に適している理由を示しています。
+
+---
+
+### 探求を始めましょうか？
+
+Semantic-TypeScriptは、複雑なデータフローを、読みやすく、合成可能で、高性能なパイプラインへと変えます。リアルタイムUIイベントの処理、大規模データセットの処理、分析ダッシュボードの構築のいずれにおいても、データベースレベルのインデックス付けの力を関数型プログラミングのエレガンスと共に提供します。
+
+次のステップ：
+
+・   IDE内で完全に型付けされたAPIを参照してください（すべてのエクスポートはメインパッケージから）。
+
+・   複雑な非同期イテレータをクリーンなSemanticパイプラインに置き換えた開発者の成長するコミュニティに参加してください。
+
+Semantic-TypeScript — ストリームが構造と出会う場所。
+
+今日から構築を始め、考え抜かれたインデックス付けがもたらす違いを体験してください。
 
-[![GitHub](./GitHub.png)](https://github.com/eloyhere/semantic-typescript)  [![NPM](./NPM.png)](https://www.npmjs.com/package/semantic-typescript)
+明確さをもって構築し、確信をもって進み、意図をもってデータを変革しましょう。