semantic-typescript 0.0.8 → 0.1.4

package/readme.de.md

@@ -1,529 +1,427 @@
-# Semantic-TypeScript Stream Processing Framework
+# Semantic-TypeScript Stream-Verarbeitungsbibliothek
 
 ## Einführung
 
-Semantic-TypeScript ist eine moderne Stream-Processing-Bibliothek, inspiriert von JavaScript GeneratorFunction, Java Stream und MySQL Index. Die Kern-Designphilosophie basiert auf dem Aufbau effizienter Datenverarbeitungspipelines durch Datenindizierung und bietet eine typsichere, funktionale Stream-Operation-Erfahrung für die Frontend-Entwicklung.
+Semantic-TypeScript ist eine moderne Stream-Verarbeitungsbibliothek, die von JavaScript GeneratorFunction, Java Stream und MySQL Index inspiriert wurde. Der Kernentwurf der Bibliothek basiert auf der Erstellung effizienter Datenverarbeitungspipelines mittels Datenindizes, um TypeScript-Entwicklern eine typsichere, funktionale Stream-Verarbeitungserfahrung zu bieten.
 
-Im Gegensatz zur traditionellen synchronen Verarbeitung verwendet Semantic ein asynchrones Verarbeitungsmodell. Beim Erstellen von Datenströmen hängt der Zeitpunkt des terminalen Datenempfangs vollständig davon ab, wann der Upstream die `accept`- und `interrupt`-Callback-Funktionen aufruft. Dieses Design ermöglicht es der Bibliothek, Echtzeit-Datenströme, große Datensätze und asynchrone Datenquellen elegant zu verarbeiten.
+Im Gegensatz zur traditionellen synchronen Verarbeitung verwendet Semantic einen asynchronen Verarbeitungsmodus. Beim Erstellen von Datenströmen hängt der Zeitpunkt des Datenempfangs vollständig davon ab, wann die Upstream-Quelle die `accept`- und `interrupt`-Callback-Funktionen aufruft. Dieser Entwurf ermöglicht der Bibliothek die elegante Verarbeitung von Echtzeit-Datenströmen, großen Datensätzen und asynchronen Datenquellen.
 
-## Kernfunktionen
+## Installation
 
-| Funktion | Beschreibung | Vorteil |
-|------|------|------|
-| **Typsichere Generics** | Vollständige TypeScript-Typunterstützung | Fehlererkennung zur Kompilierzeit, bessere Entwicklungserfahrung |
-| **Funktionale Programmierung** | Unveränderliche Datenstrukturen und reine Funktionen | Vorhersehbarerer Code, einfachere Tests und Wartung |
-| **Lazy Evaluation** | Bedarfsgerechte Berechnung, Leistungsoptimierung | Hohe Speichereffizienz bei der Verarbeitung großer Datensätze |
-| **Asynchrone Stream-Verarbeitung** | Generator-basierte asynchrone Datenströme | Geeignet für Echtzeitdaten und ereignisgesteuerte Szenarien |
-| **Multi-Paradigma-Sammler** | Geordnete, ungeordnete, statistische Sammlungsstrategien | Optimale Strategiewahl basierend auf verschiedenen Szenarien |
-| **Statistische Analyse** | Eingebaute vollständige statistische Berechnungsfunktionen | Integrierte Datenanalyse und Berichterstellungsgenerierung |
-
-## Leistungsüberlegungen
-
-**Wichtiger Hinweis**: Die folgenden Methoden opfern Leistung, um Daten zu sammeln und zu sortieren, was zu geordneten Datensammlungen führt:
-- `toOrdered()`
-- `toWindow()`
-- `toNumericStatistics()`
-- `toBigIntStatistics()`
-- `sorted()`
-- `sorted(comparator)`
-
-Besonders wichtig zu beachten: `sorted()` und `sorted(comparator)` überschreiben die Ergebnisse der folgenden Methoden:
-- `redirect(redirector)`
-- `translate(translator)`
-- `shuffle(mapper)`
-
-## Factory-Methoden
-
-### Stream-Erstellungs-Factories
+```bash
+npm install semantic-typescript
+```
 
-| Methode | Signatur | Beschreibung | Beispiel |
-|------|------|------|------|
-| `blob` | `(blob: Blob, chunk?: bigint) => Semantic<Uint8Array>` | Konvertiere Blob in Byte-Stream | `blob(fileBlob, 1024n)` |
-| `empty` | `<E>() => Semantic<E>` | Erstelle leeren Stream | `empty<number>()` |
-| `fill` | `<E>(element: E, count: bigint) => Semantic<E>` | Fülle mit angegebener Anzahl an Elementen | `fill("hallo", 5n)` |
-| `from` | `<E>(iterable: Iterable<E>) => Semantic<E>` | Erstelle Stream aus iterierbarem Objekt | `from([1, 2, 3])` |
-| `range` | `<N extends number\|bigint>(start: N, end: N, step?: N) => Semantic<N>` | Erstelle numerischen Bereichs-Stream | `range(1, 10, 2)` |
-| `iterate` | `<E>(generator: Generator<E>) => Semantic<E>` | Erstelle Stream aus Generator-Funktion | `iterate(myGenerator)` |
-| `websocket` | `(websocket: WebSocket) => Semantic<MessageEvent>` | Erstelle Ereignis-Stream aus WebSocket | `websocket(socket)` |
+## Grundlegende Typen
+
+| Typ | Beschreibung |
+|-----|-------------|
+| `Invalid<T>` | Typ, der null oder undefined erweitert |
+| `Valid<T>` | Typ, der null und undefined ausschließt |
+| `MaybeInvalid<T>` | Typ, der null oder undefined sein kann |
+| `Primitive` | Sammlung primitiver Typen |
+| `MaybePrimitive<T>` | Typ, der ein Primitiv sein kann |
+| `OptionalSymbol` | Symbolkennung für die Optional-Klasse |
+| `SemanticSymbol` | Symbolkennung für die Semantic-Klasse |
+| `CollectorsSymbol` | Symbolkennung für die Collector-Klasse |
+| `CollectableSymbol` | Symbolkennung für die Collectable-Klasse |
+| `OrderedCollectableSymbol` | Symbolkennung für die OrderedCollectable-Klasse |
+| `WindowCollectableSymbol` | Symbolkennung für die WindowCollectable-Klasse |
+| `StatisticsSymbol` | Symbolkennung für die Statistics-Klasse |
+| `NumericStatisticsSymbol` | Symbolkennung für die NumericStatistics-Klasse |
+| `BigIntStatisticsSymbol` | Symbolkennung für die BigIntStatistics-Klasse |
+| `UnorderedCollectableSymbol` | Symbolkennung für die UnorderedCollectable-Klasse |
+| `Runnable` | Funktion ohne Parameter und Rückgabewert |
+| `Supplier<R>` | Funktion ohne Parameter, die R zurückgibt |
+| `Functional<T, R>` | Ein-Parameter-Transformationsfunktion |
+| `Predicate<T>` | Ein-Parameter-Prüffunktion |
+| `BiFunctional<T, U, R>` | Zwei-Parameter-Transformationsfunktion |
+| `BiPredicate<T, U>` | Zwei-Parameter-Prüffunktion |
+| `Comparator<T>` | Vergleichsfunktion |
+| `TriFunctional<T, U, V, R>` | Drei-Parameter-Transformationsfunktion |
+| `Consumer<T>` | Ein-Parameter-Consumer-Funktion |
+| `BiConsumer<T, U>` | Zwei-Parameter-Consumer-Funktion |
+| `TriConsumer<T, U, V>` | Drei-Parameter-Consumer-Funktion |
+| `Generator<T>` | Generatorfunktion |
 
-**Code-Beispiel-Ergänzung:**
 ```typescript
-import { from, range, fill, empty } from 'semantic-typescript';
-
-// Erstelle Stream aus Array
-const numberStream = from([1, 2, 3, 4, 5]);
-
-// Erstelle numerischen Bereichs-Stream
-const rangeStream = range(1, 10, 2); // 1, 3, 5, 7, 9
-
-// Fülle mit wiederholten Elementen
-const filledStream = fill("hallo", 3n); // "hallo", "hallo", "hallo"
-
-// Erstelle leeren Stream
-const emptyStream = empty<number>();
+// Typverwendungsbeispiele
+const predicate: Predicate<number> = (n) => n > 0;
+const mapper: Functional<string, number> = (str) => str.length;
+const comparator: Comparator<number> = (a, b) => a - b;
 ```
 
-### Hilfsfunktions-Factories
-
-| Methode | Signatur | Beschreibung | Beispiel |
-|------|------|------|------|
-| `validate` | `<T>(t: MaybeInvalid<T>) => t is T` | Validiere ob Wert gültig ist | `validate(null)` → `false` |
-| `invalidate` | `<T>(t: MaybeInvalid<T>) => t is null\|undefined` | Validiere ob Wert ungültig ist | `invalidate(0)` → `false` |
-| `useCompare` | `<T>(t1: T, t2: T) => number` | Generische Vergleichsfunktion | `useCompare("a", "b")` → `-1` |
-| `useRandom` | `<T = number\|bigint>(index: T) => T` | Pseudozufallszahlengenerator | `useRandom(5)` → Zufallszahl |
+## Typwächter (Type Guards)
+
+| Funktion | Beschreibung | Zeitkomplexität | Raumkomplexität |
+|----------|-------------|-----------------|-----------------|
+| `validate<T>(t: MaybeInvalid<T>): t is T` | Prüft, ob Wert nicht null oder undefined | O(1) | O(1) |
+| `invalidate<T>(t: MaybeInvalid<T>): t is null \| undefined` | Prüft, ob Wert null oder undefined | O(1) | O(1) |
+| `isBoolean(t: unknown): t is boolean` | Prüft auf Boolean | O(1) | O(1) |
+| `isString(t: unknown): t is string` | Prüft auf String | O(1) | O(1) |
+| `isNumber(t: unknown): t is number` | Prüft auf Number | O(1) | O(1) |
+| `isFunction(t: unknown): t is Function` | Prüft auf Function | O(1) | O(1) |
+| `isObject(t: unknown): t is object` | Prüft auf Object | O(1) | O(1) |
+| `isSymbol(t: unknown): t is symbol` | Prüft auf Symbol | O(1) | O(1) |
+| `isBigint(t: unknown): t is bigint` | Prüft auf BigInt | O(1) | O(1) |
+| `isPrimitive(t: unknown): t is Primitive` | Prüft auf Primitivtyp | O(1) | O(1) |
+| `isIterable(t: unknown): t is Iterable<unknown>` | Prüft auf Iterierbarkeit | O(1) | O(1) |
+| `isOptional(t: unknown): t is Optional<unknown>` | Prüft auf Optional-Instanz | O(1) | O(1) |
+| `isSemantic(t: unknown): t is Semantic<unknown>` | Prüft auf Semantic-Instanz | O(1) | O(1) |
+| `isCollector(t: unknown): t is Collector<unknown, unknown, unknown>` | Prüft auf Collector-Instanz | O(1) | O(1) |
+| `isCollectable(t: unknown): t is Collectable<unknown>` | Prüft auf Collectable-Instanz | O(1) | O(1) |
+| `isOrderedCollectable(t: unknown): t is OrderedCollectable<unknown>` | Prüft auf OrderedCollectable-Instanz | O(1) | O(1) |
+| `isWindowCollectable(t: unknown): t is WindowCollectable<unknown>` | Prüft auf WindowCollectable-Instanz | O(1) | O(1) |
+| `isUnorderedCollectable(t: unknown): t is UnorderedCollectable<unknown>` | Prüft auf UnorderedCollectable-Instanz | O(1) | O(1) |
+| `isStatistics(t: unknown): t is Statistics<unknown, number \| bigint>` | Prüft auf Statistics-Instanz | O(1) | O(1) |
+| `isNumericStatistics(t: unknown): t is NumericStatistics<unknown>` | Prüft auf NumericStatistics-Instanz | O(1) | O(1) |
+| `isBigIntStatistics(t: unknown): t is BigIntStatistics<unknown>` | Prüft auf BigIntStatistics-Instanz | O(1) | O(1) |
 
-**Code-Beispiel-Ergänzung:**
 ```typescript
-import { validate, invalidate, useCompare, useRandom } from 'semantic-typescript';
+// Typwächter-Verwendungsbeispiele
+const value: unknown = "hello";
 
-// Validiere Datenvalidität
-const data: string | null = "hallo";
-if (validate(data)) {
-    console.log(data.toUpperCase()); // Sichere Aufruf, da validate sicherstellt, dass Daten nicht null sind
+if (isString(value)) {
+    console.log(value.length); // Typsicher, value wird als string inferiert
 }
 
-const nullData: string | null = null;
-if (invalidate(nullData)) {
-    console.log("Daten ungültig"); // Wird ausgeführt, da invalidate null erkannt hat
+if (isOptional(someValue)) {
+    someValue.ifPresent(val => console.log(val));
 }
-
-// Vergleiche Werte
-const comparison = useCompare("Apfel", "Banane"); // -1
-
-// Generiere Zufallszahl
-const randomNum = useRandom(42); // Zufallszahl basierend auf Seed 42
 ```
 
-## Kernklassen-Details
-
-### Optional<T> - Sichere Nullwert-Behandlung
-
-Die Optional-Klasse bietet einen funktionalen Ansatz zur sicheren Handhabung von Werten, die null oder undefined sein könnten.
+## Hilfsfunktionen
 
-| Methode | Rückgabetyp | Beschreibung | Zeitkomplexität |
-|------|----------|------|------------|
-| `filter(predicate: Predicate<T>)` | `Optional<T>` | Filtere Werte, die Bedingung erfüllen | O(1) |
-| `get()` | `T` | Hole Wert, wirft Fehler wenn leer | O(1) |
-| `getOrDefault(defaultValue: T)` | `T` | Hole Wert oder Standardwert | O(1) |
-| `ifPresent(action: Consumer<T>)` | `void` | Führe Aktion aus wenn Wert existiert | O(1) |
-| `isEmpty()` | `boolean` | Prüfe ob leer | O(1) |
-| `isPresent()` | `boolean` | Prüfe ob Wert existiert | O(1) |
-| `map<R>(mapper: Functional<T, R>)` | `Optional<R>` | Mappe und transformiere Wert | O(1) |
-| `static of<T>(value: MaybeInvalid<T>)` | `Optional<T>` | Erstelle Optional-Instanz | O(1) |
-| `static ofNullable<T>(value?)` | `Optional<T>` | Erstelle nullable Optional | O(1) |
-| `static ofNonNull<T>(value: T)` | `Optional<T>` | Erstelle Non-Null Optional | O(1) |
+| Funktion | Beschreibung | Zeitkomplexität | Raumkomplexität |
+|----------|-------------|-----------------|-----------------|
+| `useCompare<T>(t1: T, t2: T): number` | Allgemeine Vergleichsfunktion | O(1) | O(1) |
+| `useRandom<T = number \| bigint>(index: T): T` | Pseudozufallszahlengenerator | O(log n) | O(1) |
 
-**Code-Beispiel-Ergänzung:**
 ```typescript
-import { Optional } from 'semantic-typescript';
+// Hilfsfunktions-Verwendungsbeispiele
+const numbers = [3, 1, 4, 1, 5];
+numbers.sort(useCompare); // [1, 1, 3, 4, 5]
 
-// Erstelle Optional-Instanz
-const optionalValue = Optional.ofNullable<string>(Math.random() > 0.5 ? "hallo" : null);
+const randomNum = useRandom(42); // Seed-basierte Zufallszahl
+const randomBigInt = useRandom(1000n); // BigInt-Zufallszahl
+```
 
-// Kettenoperationen
-const result = optionalValue
-    .filter(val => val.length > 3) // Filtere Werte länger als 3
-    .map(val => val.toUpperCase()) // Konvertiere zu Großbuchstaben
-    .getOrDefault("standard"); // Hole Wert oder Standard
+## Fabrikmethoden
 
-console.log(result); // "HALLO" oder "standard"
+### Optional-Fabrikmethoden
 
-// Sichere Operationen
-optionalValue.ifPresent(val => {
-    console.log(`Wert existiert: ${val}`);
-});
+| Methode | Beschreibung | Zeitkomplexität | Raumkomplexität |
+|---------|-------------|-----------------|-----------------|
+| `Optional.empty<T>()` | Erstellt leeres Optional | O(1) | O(1) |
+| `Optional.of<T>(value)` | Erstellt Optional mit Wert | O(1) | O(1) |
+| `Optional.ofNullable<T>(value)` | Erstellt Optional, das null sein kann | O(1) | O(1) |
+| `Optional.ofNonNull<T>(value)` | Erstellt nicht-null Optional | O(1) | O(1) |
 
-// Prüfe Status
-if (optionalValue.isPresent()) {
-    console.log("Hat Wert");
-} else if (optionalValue.isEmpty()) {
-    console.log("Ist leer");
-}
+```typescript
+// Optional-Verwendungsbeispiele
+const emptyOpt = Optional.empty<number>();
+const presentOpt = Optional.of(42);
+const nullableOpt = Optional.ofNullable<string>(null);
+const nonNullOpt = Optional.ofNonNull("hello");
+
+presentOpt.ifPresent(val => console.log(val)); // Gibt 42 aus
+console.log(emptyOpt.orElse(100)); // Gibt 100 aus
 ```
 
-### Semantic<E> - Lazy Datenstrom
-
-Semantic ist die Kern-Stream-Verarbeitungsklasse und bietet reichhaltige Stream-Operatoren.
-
-#### Stream-Transformations-Operationen
-
-| Methode | Rückgabetyp | Beschreibung | Leistungsauswirkung |
-|------|----------|------|----------|
-| `concat(other: Semantic<E>)` | `Semantic<E>` | Verkette zwei Streams | O(n+m) |
-| `distinct()` | `Semantic<E>` | Entferne Duplikate (mit Set) | O(n) |
-| `distinct(comparator)` | `Semantic<E>` | Benutzerdefinierte Comparator-Deduplizierung | O(n²) |
-| `dropWhile(predicate)` | `Semantic<E>` | Verwerfe Startelemente, die Bedingung erfüllen | O(n) |
-| `filter(predicate)` | `Semantic<E>` | Filtere Elemente | O(n) |
-| `flat(mapper)` | `Semantic<E>` | Glätte verschachtelte Streams | O(n×m) |
-| `flatMap(mapper)` | `Semantic<R>` | Mappe und glätte | O(n×m) |
-| `limit(n)` | `Semantic<E>` | Begrenze Anzahl der Elemente | O(n) |
-| `map(mapper)` | `Semantic<R>` | Mappe und transformiere Elemente | O(n) |
-| `peek(consumer)` | `Semantic<E>` | Betrachte Elemente ohne Modifikation | O(n) |
-| `redirect(redirector)` | `Semantic<E>` | Leite Indizes um | O(n) |
-| `reverse()` | `Semantic<E>` | Kehre Stream-Reihenfolge um | O(n) |
-| `shuffle()` | `Semantic<E>` | Mische Reihenfolge zufällig | O(n) |
-| `shuffle(mapper)` | `Semantic<E>` | Benutzerdefinierte Shuffle-Logik | O(n) |
-| `skip(n)` | `Semantic<E>` | Überspringe erste n Elemente | O(n) |
-| `sub(start, end)` | `Semantic<E>` | Hole Substream | O(n) |
-| `takeWhile(predicate)` | `Semantic<E>` | Hole Startelemente, die Bedingung erfüllen | O(n) |
-| `translate(offset)` | `Semantic<E>` | Übersetze Indizes | O(n) |
-| `translate(translator)` | `Semantic<E>` | Benutzerdefinierte Index-Transformation | O(n) |
-
-**Code-Beispiel-Ergänzung:**
-```typescript
-import { from } from 'semantic-typescript';
+### Collector-Fabrikmethoden
 
-const stream = from([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
+| Methode | Beschreibung | Zeitkomplexität | Raumkomplexität |
+|---------|-------------|-----------------|-----------------|
+| `Collector.full(identity, accumulator, finisher)` | Erstellt vollständigen Collector | O(1) | O(1) |
+| `Collector.shortable(identity, interruptor, accumulator, finisher)` | Erstellt unterbrechbaren Collector | O(1) | O(1) |
 
-// Stream-Transformations-Operationsbeispiele
-const processedStream = stream
-    .filter(x => x % 2 === 0) // Filtere gerade Zahlen
-    .map(x => x * 2) // Multipliziere jedes Element mit 2
-    .distinct() // Entferne Duplikate
-    .limit(3) // Begrenze auf erste 3 Elemente
-    .peek((val, index) => console.log(`Element ${val} an Index ${index}`)); // Betrachte Elemente
+```typescript
+// Collector-Verwendungsbeispiele
+const sumCollector = Collector.full(
+    () => 0,
+    (sum, num) => sum + num,
+    result => result
+);
 
-// Hinweis: Der Stream wurde noch nicht ausgeführt, muss zu Collectable konvertiert werden für Terminaloperationen
+const numbers = from([1, 2, 3, 4, 5]);
+const total = numbers.toUnoredered().collect(sumCollector); // 15
 ```
 
-#### Stream-Terminaloperationen
+### Semantic-Fabrikmethoden
 
-| Methode | Rückgabetyp | Beschreibung | Leistungscharakteristiken |
-|------|----------|------|----------|
-| `toOrdered()` | `OrderedCollectable<E>` | Konvertiere zu geordneter Sammlung | Sortieroperation, geringere Leistung |
-| `toUnordered()` | `UnorderedCollectable<E>` | Konvertiere zu ungeordneter Sammlung | Schnellste, keine Sortierung |
-| `toWindow()` | `WindowCollectable<E>` | Konvertiere zu Fenster-Sammlung | Sortieroperation, geringere Leistung |
-| `toNumericStatistics()` | `Statistics<E, number>` | Numerische statistische Analyse | Sortieroperation, geringere Leistung |
-| `toBigintStatistics()` | `Statistics<E, bigint>` | Big Integer statistische Analyse | Sortieroperation, geringere Leistung |
-| `sorted()` | `OrderedCollectable<E>` | Natürliche Sortierung | Überschreibt Umleitungsergebnisse |
-| `sorted(comparator)` | `OrderedCollectable<E>` | Benutzerdefinierte Sortierung | Überschreibt Umleitungsergebnisse |
+| Methode | Beschreibung | Zeitkomplexität | Raumkomplexität |
+|---------|--------------|-----------------|-----------------|
+| `blob(blob, chunkSize)` | Erzeugt Stream aus Blob | O(n) | O(chunkSize) |
+| `empty<E>()` | Erzeugt leeren Stream | O(1) | O(1) |
+| `fill<E>(element, count)` | Erzeugt gefüllten Stream | O(n) | O(1) |
+| `from<E>(iterable)` | Erzeugt Stream aus iterierbarem Objekt | O(1) | O(1) |
+| `interval(period, delay?)` | Erzeugt regelmäßigen Intervall-Stream | O(1)* | O(1) |
+| `iterate<E>(generator)` | Erzeugt Stream aus Generator | O(1) | O(1) |
+| `range(start, end, step)` | Erzeugt numerischen Bereichs-Stream | O(n) | O(1) |
+| `websocket(websocket)` | Erzeugt Stream aus WebSocket | O(1) | O(1) |
 
-**Code-Beispiel-Ergänzung:**
 ```typescript
-import { from } from 'semantic-typescript';
+// Beispiel zur Verwendung der Semantic-Fabrikmethoden
 
-const semanticStream = from([5, 2, 8, 1, 9, 3, 7, 4, 6]);
+// Stream aus Blob erzeugen (chunkweises Lesen)
+blob(someBlob, 1024n)
+  .toUnordered()
+  .write(WritableStream)
+  .then(callback) // Stream-Schreibvorgang erfolgreich
+  .catch(writeFi); // Stream-Schreibvorgang fehlgeschlagen
 
-// Konvertiere zu geordneter Sammlung (geringere Leistung)
-const ordered = semanticStream.toOrdered();
+// Leeren Stream erzeugen, der erst nach Verknüpfung mit anderen Streams ausgeführt wird
+empty<string>()
+  .toUnordered()
+  .join(); //[]
 
-// Konvertiere zu ungeordneter Sammlung (schnellste)
-const unordered = semanticStream.toUnordered();
+// Gefüllten Stream erzeugen
+const filledStream = fill("hello", 3); // "hello", "hello", "hello"
 
-// Natürliche Sortierung
-const sortedNatural = semanticStream.sorted();
+// Zeitgesteuerten Stream mit 2 Sekunden anfänglicher Verzögerung und 5 Sekunden Zyklus erzeugen, 
+// implementiert über Timer-Mechanismus, mögliche Zeitabweichungen aufgrund von System-Schedulereinschränkungen.
+const intervalStream = interval(5000, 2000);
 
-// Benutzerdefinierte Sortierung
-const sortedCustom = semanticStream.sorted((a, b) => b - a); // Absteigende Sortierung
+// Stream aus iterierbarem Objekt erzeugen
+const numberStream = from([1, 2, 3, 4, 5]);
+const stringStream = from(new Set(["Alex", "Bob"]));
 
-// Konvertiere zu statistischem Objekt
-const stats = semanticStream.toNumericStatistics();
+// Bereichs-Stream erzeugen
+const rangeStream = range(1, 10, 2); // 1, 3, 5, 7, 9
 
-// Hinweis: Muss obige Methoden durch Semantic-Instanz aufrufen, um Collectable zu erhalten, bevor Terminalmethoden verwendet werden
+// WebSocket-Ereignisstream
+const ws = new WebSocket("ws://localhost:8080");
+websocket(ws)
+  .filter((event)=> event.type === "message") // Nur Nachrichtenereignisse überwachen
+  .toUnordered() // Für Ereignisse normalerweise ungeordnet
+  .forEach((event)=> receive(event)); // Nachrichten empfangen
 ```
 
-### Collector<E, A, R> - Datensammler
-
-Collectors werden verwendet, um Stream-Daten in spezifische Strukturen zu aggregieren.
+## Semantic-Klassenmethoden
+
+| Methode | Beschreibung | Zeitkomplexität | Raumkomplexität |
+|---------|-------------|-----------------|-----------------|
+| `concat(other)` | Verbindet zwei Streams | O(n) | O(1) |
+| `distinct()` | Entfernt Duplikate | O(n) | O(n) |
+| `distinct(comparator)` | Entfernt Duplikate mit Comparator | O(n²) | O(n) |
+| `dropWhile(predicate)` | Verwirft Elemente, die Prädikat erfüllen | O(n) | O(1) |
+| `filter(predicate)` | Filtert Elemente | O(n) | O(1) |
+| `flat(mapper)` | Flache Abbildung | O(n × m) | O(1) |
+| `flatMap(mapper)` | Flache Abbildung auf neuen Typ | O(n × m) | O(1) |
+| `limit(n)` | Begrenzt Elementanzahl | O(n) | O(1) |
+| `map(mapper)` | Transformationsabbildung | O(n) | O(1) |
+| `peek(consumer)` | Zeigt Elemente an | O(n) | O(1) |
+| `redirect(redirector)` | Index-Umleitung | O(n) | O(1) |
+| `reverse()` | Kehrt Stream um | O(n) | O(1) |
+| `shuffle()` | Zufällige Neuanordnung | O(n) | O(1) |
+| `shuffle(mapper)` | Neuanordnung mit Mapper | O(n) | O(1) |
+| `skip(n)` | Überspringt erste n Elemente | O(n) | O(1) |
+| `sorted()` | Sortiert | O(n log n) | O(n) |
+| `sorted(comparator)` | Sortiert mit Comparator | O(n log n) | O(n) |
+| `sub(start, end)` | Erstellt Substream | O(n) | O(1) |
+| `takeWhile(predicate)` | Nimmt Elemente, die Prädikat erfüllen | O(n) | O(1) |
+| `translate(offset)` | Index-Translation | O(n) | O(1) |
+| `translate(translator)` | Index-Translation mit Translator | O(n) | O(1) |
 
-| Methode | Beschreibung | Verwendungsszenario |
-|------|------|----------|
-| `collect(generator)` | Führe Datensammlung aus | Stream-Terminaloperation |
-| `static full(identity, accumulator, finisher)` | Erstelle vollständigen Collector | Erfordert vollständige Verarbeitung |
-| `static shortable(identity, interruptor, accumulator, finisher)` | Erstelle unterbrechbaren Collector | Kann vorzeitig beendet werden |
-
-**Code-Beispiel-Ergänzung:**
 ```typescript
-import { Collector } from 'semantic-typescript';
-
-// Erstelle benutzerdefinierten Collector
-const sumCollector = Collector.full(
-    () => 0, // Initialwert
-    (acc, value) => acc + value, // Akkumulator
-    result => result // Finisher-Funktion
-);
-
-// Verwende Collector (erfordert Konvertierung von Semantic zu Collectable zuerst)
-const numbers = from([1, 2, 3, 4, 5]);
-const sum = numbers.toUnordered().collect(sumCollector); // 15
+// Semantic-Operationsbeispiele
+const result = from([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
+    .filter(n => n % 2 === 0)        // Filtert gerade Zahlen
+    .map(n => n * 2)                 // Multipliziert mit 2
+    .skip(1)                         // Überspringt erstes Element
+    .limit(3)                        // Begrenzt auf 3 Elemente
+    .toArray();                      // Konvertiert zu Array
+// Ergebnis: [8, 12, 20]
+
+// Komplexe Operationsbeispiele
+const complexResult = range(1, 100, 1)
+    .flatMap(n => from([n, n * 2])) // Abbildet jedes Element zu zwei Elementen
+    .distinct()                      // Entfernt Duplikate
+    .shuffle()                       // Mischt zufällig
+    .takeWhile(n => n < 50)         // Nimmt Elemente < 50
+    .toOrdered()                     // Konvertiert zu geordnetem Collector
+    .toArray();                      // Konvertiert zu Array
 ```
 
-### Collectable<E> - Sammelbare Daten Abstrakte Klasse
+## Collector-Transformationsmethoden
 
-Bietet reichhaltige Datenaggregations- und Transformationsmethoden. **Hinweis: Muss zuerst Collectable-Instanz erhalten, indem sorted(), toOrdered() etc. durch Semantic-Instanz aufgerufen werden, bevor die folgenden Methoden verwendet werden können.**
+| Methode | Beschreibung | Zeitkomplexität | Raumkomplexität |
+|---------|-------------|-----------------|-----------------|
+| `toUnoredered()` | Konvertiert zu ungeordnetem Collector (Leistungspriorität) | O(1) | O(1) |
+| `toOrdered()` | Konvertiert zu geordnetem Collector | O(1) | O(1) |
+| `sorted()` | Sortiert und konvertiert zu geordnetem Collector | O(n log n) | O(n) |
+| `toWindow()` | Konvertiert zu Fenster-Collector | O(1) | O(1) |
+| `toNumericStatistics()` | Konvertiert zu numerischer Statistik | O(1) | O(1) |
+| `toBigintStatistics()` | Konvertiert zu BigInt-Statistik | O(1) | O(1) |
 
-#### Datenabfrage-Operationen
+```typescript
+// Collector-Transformationsbeispiele
+const numbers = from([3, 1, 4, 1, 5, 9, 2, 6, 5]);
 
-| Methode | Rückgabetyp | Beschreibung | Beispiel |
-|------|----------|------|------|
-| `anyMatch(predicate)` | `boolean` | Ob irgendein Element übereinstimmt | `anyMatch(x => x > 0)` |
-| `allMatch(predicate)` | `boolean` | Ob alle Elemente übereinstimmen | `allMatch(x => x > 0)` |
-| `count()` | `bigint` | Elementanzahl-Statistiken | `count()` → `5n` |
-| `isEmpty()` | `boolean` | Ob Stream leer ist | `isEmpty()` |
-| `findAny()` | `Optional<E>` | Finde irgendein Element | `findAny()` |
-| `findFirst()` | `Optional<E>` | Finde erstes Element | `findFirst()` |
-| `findLast()` | `Optional<E>` | Finde letztes Element | `findLast()` |
+// Leistungspriorität: Ungeordneten Collector verwenden
+const unordered = numbers
+    .filter(n => n > 3)
+    .toUnoredered();
 
-**Code-Beispiel-Ergänzung:**
-```typescript
-import { from } from 'semantic-typescript';
+// Sortierung benötigt: Geordneten Collector verwenden  
+const ordered = numbers.sorted();
 
-const numbers = from([1, 2, 3, 4, 5]);
+// Statistische Analyse: Statistik-Collector verwenden
+const stats = numbers
+    .toNumericStatistics();
+
+console.log(stats.mean());        // Durchschnitt
+console.log(stats.median());      // Median
+console.log(stats.standardDeviation()); // Standardabweichung
 
-// Muss zu Collectable konvertiert werden, bevor Terminalmethoden verwendet werden
-const collectable = numbers.toUnordered();
+// Fensteroperationen
+const windowed = numbers
+    .toWindow()
+    .tumble(3n); // Fenster mit je 3 Elementen
 
-// Datenabfrage-Operationen
-const hasEven = collectable.anyMatch(x => x % 2 === 0); // true
-const allPositive = collectable.allMatch(x => x > 0); // true
-const count = collectable.count(); // 5n
-const isEmpty = collectable.isEmpty(); // false
-const firstElement = collectable.findFirst(); // Optional.of(1)
-const anyElement = collectable.findAny(); // Irgendein Element
+windowed.forEach(window => {
+    console.log(window.toArray()); // Inhalt jedes Fensters
+});
 ```
 
-#### Datenaggregations-Operationen
-
-| Methode | Rückgabetyp | Beschreibung | Komplexität |
-|------|----------|------|--------|
-| `group(classifier)` | `Map<K, E[]>` | Gruppiere nach Classifier | O(n) |
-| `groupBy(keyExtractor, valueExtractor)` | `Map<K, V[]>` | Gruppiere nach Schlüssel-Wert-Extraktoren | O(n) |
-| `join()` | `string` | Verbinde als String | O(n) |
-| `join(delimiter)` | `string` | Verbinde mit Trennzeichen | O(n) |
-| `partition(count)` | `E[][]` | Partitioniere nach Anzahl | O(n) |
-| `partitionBy(classifier)` | `E[][]` | Partitioniere nach Classifier | O(n) |
-| `reduce(accumulator)` | `Optional<E>` | Reduktionsoperation | O(n) |
-| `reduce(identity, accumulator)` | `E` | Reduktion mit Identität | O(n) |
-| `toArray()` | `E[]` | Konvertiere zu Array | O(n) |
-| `toMap(keyExtractor, valueExtractor)` | `Map<K, V>` | Konvertiere zu Map | O(n) |
-| `toSet()` | `Set<E>` | Konvertiere zu Set | O(n) |
-
-**Code-Beispiel-Ergänzung:**
+## Collectable-Sammelmethoden
+
+| Methode | Beschreibung | Zeitkomplexität | Raumkomplexität |
+|---------|-------------|-----------------|-----------------|
+| `anyMatch(predicate)` | Prüft auf existierende Übereinstimmung | O(n) | O(1) |
+| `allMatch(predicate)` | Prüft auf vollständige Übereinstimmung | O(n) | O(1) |
+| `count()` | Elementzählung | O(n) | O(1) |
+| `isEmpty()` | Prüft auf Leerheit | O(1) | O(1) |
+| `findAny()` | Findet beliebiges Element | O(n) | O(1) |
+| `findFirst()` | Findet erstes Element | O(n) | O(1) |
+| `findLast()` | Findet letztes Element | O(n) | O(1) |
+| `forEach(action)` | Iteriert über alle Elemente | O(n) | O(1) |
+| `group(classifier)` | Gruppiert nach Klassifikator | O(n) | O(n) |
+| `groupBy(keyExtractor, valueExtractor)` | Gruppiert nach Schlüssel-Wert-Extraktor | O(n) | O(n) |
+| `join()` | Verbindet zu String | O(n) | O(n) |
+| `join(delimiter)` | Verbindet mit Trennzeichen | O(n) | O(n) |
+| `nonMatch(predicate)` | Prüft auf keine Übereinstimmung | O(n) | O(1) |
+| `partition(count)` | Partitioniert nach Anzahl | O(n) | O(n) |
+| `partitionBy(classifier)` | Partitioniert nach Klassifikator | O(n) | O(n) |
+| `reduce(accumulator)` | Reduktionsoperation | O(n) | O(1) |
+| `reduce(identity, accumulator)` | Reduktion mit Initialwert | O(n) | O(1) |
+| `toArray()` | Konvertiert zu Array | O(n) | O(n) |
+| `toMap(keyExtractor, valueExtractor)` | Konvertiert zu Map | O(n) | O(n) |
+| `toSet()` | Konvertiert zu Set | O(n) | O(n) |
+| `write(stream)` | Schreibt in Stream | O(n) | O(1) |
+
 ```typescript
-import { from } from 'semantic-typescript';
+// Collectable-Operationsbeispiele
+const data = from([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
+    .filter(n => n % 2 === 0)
+    .toOrdered();
 
-const people = from([
-    { name: "Alice", age: 25, city: "New York" },
-    { name: "Bob", age: 30, city: "London" },
-    { name: "Charlie", age: 25, city: "New York" }
-]);
+// Übereinstimmungsprüfungen
+console.log(data.anyMatch(n => n > 5)); // true
+console.log(data.allMatch(n => n < 20)); // true
 
-// Muss zu Collectable konvertiert werden, bevor Aggregationsoperationen verwendet werden
-const collectable = people.toUnordered();
+// Suchoperationen
+data.findFirst().ifPresent(n => console.log(n)); // 2
+data.findAny().ifPresent(n => console.log(n)); // Beliebiges Element
 
 // Gruppierungsoperationen
-const byCity = collectable.group(person => person.city);
-// Map { "New York" => [{name: "Alice", ...}, {name: "Charlie", ...}], "London" => [{name: "Bob", ...}] }
-
-const byAge = collectable.groupBy(
-    person => person.age,
-    person => person.name
+const grouped = data.groupBy(
+    n => n > 5 ? "large" : "small",
+    n => n * 2
 );
-// Map { 25 => ["Alice", "Charlie"], 30 => ["Bob"] }
-
-// Konvertiere zu Sammlungen
-const array = collectable.toArray(); // Ursprüngliches Array
-const set = collectable.toSet(); // Set-Sammlung
-const map = collectable.toMap(
-    person => person.name,
-    person => person.age
-); // Map { "Alice" => 25, "Bob" => 30, "Charlie" => 25 }
+// {small: [4, 8], large: [12, 16, 20]}
 
 // Reduktionsoperationen
-const totalAge = collectable.reduce(0, (acc, person) => acc + person.age); // 80
-const oldest = collectable.reduce((a, b) => a.age > b.age ? a : b); // Optional.of({name: "Bob", age: 30, ...})
-```
-
-### Spezifische Collector-Implementierungen
+const sum = data.reduce(0, (acc, n) => acc + n); // 30
 
-#### UnorderedCollectable<E>
-- **Charakteristiken**: Schnellster Collector, keine Sortierung
-- **Verwendungsszenarien**: Reihenfolge unwichtig, maximale Leistung gewünscht
-- **Methoden**: Erbt alle Collectable-Methoden
-
-#### OrderedCollectable<E>
-- **Charakteristiken**: Garantiert Elementreihenfolge, geringere Leistung
-- **Verwendungsszenarien**: Erfordern sortierte Ergebnisse
-- **Spezielle Methoden**: Erbt alle Methoden, behält internen Sortierzustand bei
+// Ausgabeoperationen
+data.join(", "); // "2, 4, 6, 8, 10"
+```
 
-#### WindowCollectable<E>
-- **Charakteristiken**: Unterstützt Gleitfenster-Operationen
-- **Verwendungsszenarien**: Zeitreihendatenanalyse
-- **Spezielle Methoden**:
-  - `slide(size, step)` - Gleitfenster
-  - `tumble(size)` - Tumbling-Fenster
+## Statistische Analysemethoden
+
+### NumericStatistics-Methoden
+
+| Methode | Beschreibung | Zeitkomplexität | Raumkomplexität |
+|---------|-------------|-----------------|-----------------|
+| `range()` | Spannweite | O(n) | O(1) |
+| `variance()` | Varianz | O(n) | O(1) |
+| `standardDeviation()` | Standardabweichung | O(n) | O(1) |
+| `mean()` | Mittelwert | O(n) | O(1) |
+| `median()` | Median | O(n log n) | O(n) |
+| `mode()` | Modus | O(n) | O(n) |
+| `frequency()` | Häufigkeitsverteilung | O(n) | O(n) |
+| `summate()` | Summierung | O(n) | O(1) |
+| `quantile(quantile)` | Quantil | O(n log n) | O(n) |
+| `interquartileRange()` | Interquartilsabstand | O(n log n) | O(n) |
+| `skewness()` | Schiefe | O(n) | O(1) |
+| `kurtosis()` | Wölbung | O(n) | O(1) |
 
-**Code-Beispiel-Ergänzung:**
 ```typescript
-import { from } from 'semantic-typescript';
-
-const data = from([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
-
-// Ungeordneter Collector (schnellste)
-const unordered = data.toUnordered();
-const unorderedArray = unordered.toArray(); // Kann ursprüngliche Reihenfolge beibehalten [1, 2, 3, ...]
-
-// Geordneter Collector
-const ordered = data.toOrdered();
-const orderedArray = ordered.toArray(); // Garantiert sortiert [1, 2, 3, ...]
+// Statistische Analysebeispiele
+const numbers = from([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
+    .toNumericStatistics();
+
+console.log("Mittelwert:", numbers.mean()); // 5.5
+console.log("Median:", numbers.median()); // 5.5
+console.log("Standardabweichung:", numbers.standardDeviation()); // ~2.87
+console.log("Summe:", numbers.summate()); // 55
+
+// Statistische Analyse mit Mapper
+const objects = from([
+    { value: 10 },
+    { value: 20 }, 
+    { value: 30 }
+]).toNumericStatistics();
+
+console.log("Gemappter Mittelwert:", objects.mean(obj => obj.value)); // 20
+```
 
-// Fenster-Collector
-const windowed = data.toWindow();
-const slidingWindows = windowed.slide(3n, 2n); // Fenstergröße 3, Schritt 2
-// Fenster 1: [1, 2, 3], Fenster 2: [3, 4, 5], Fenster 3: [5, 6, 7], ...
+## Leistungsauswahlleitfaden
 
-const tumblingWindows = windowed.tumble(4n); // Tumbling-Fenster Größe 4
-// Fenster 1: [1, 2, 3, 4], Fenster 2: [5, 6, 7, 8], ...
+### Ungeordneten Collector wählen (Leistungspriorität)
+```typescript
+// Wenn keine Reihenfolgegarantie benötigt wird
+const highPerformance = data
+    .filter(predicate)
+    .map(mapper)
+    .toUnoredered(); // Beste Leistung
 ```
 
-### Statistics<E, D> - Statistische Analyse
-
-Statistische Analyse-Basisklasse, die reichhaltige statistische Berechnungsmethoden bietet. **Hinweis: Muss zuerst Statistics-Instanz erhalten, indem toNumericStatistics() oder toBigIntStatistics() durch Semantic-Instanz aufgerufen werden, bevor die folgenden Methoden verwendet werden können.**
-
-#### Statistische Berechnungs-Operationen
-
-| Methode | Rückgabetyp | Beschreibung | Algorithmus-Komplexität |
-|------|----------|------|------------|
-| `maximum()` | `Optional<E>` | Maximalwert | O(n) |
-| `minimum()` | `Optional<E>` | Minimalwert | O(n) |
-| `range()` | `D` | Bereich (max-min) | O(n) |
-| `variance()` | `D` | Varianz | O(n) |
-| `standardDeviation()` | `D` | Standardabweichung | O(n) |
-| `mean()` | `D` | Mittelwert | O(n) |
-| `median()` | `D` | Medianwert | O(n log n) |
-| `mode()` | `D` | Modalwert | O(n) |
-| `frequency()` | `Map<D, bigint>` | Häufigkeitsverteilung | O(n) |
-| `summate()` | `D` | Summierung | O(n) |
-| `quantile(quantile)` | `D` | Quantil | O(n log n) |
-| `interquartileRange()` | `D` | Interquartilsabstand | O(n log n) |
-| `skewness()` | `D` | Schiefe | O(n) |
-| `kurtosis()` | `D` | Kurtosis | O(n) |
-
-**Code-Beispiel-Ergänzung:**
+### Geordneten Collector wählen (Reihenfolge benötigt)
 ```typescript
-import { from } from 'semantic-typescript';
-
-const numbers = from([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
-
-// Muss zu statistischem Objekt konvertiert werden, bevor statistische Methoden verwendet werden
-const stats = numbers.toNumericStatistics();
-
-// Grundlegende Statistiken
-const count = stats.count(); // 10n
-const max = stats.maximum(); // Optional.of(10)
-const min = stats.minimum(); // Optional.of(1)
-const range = stats.range(); // 9
-const mean = stats.mean(); // 5.5
-const median = stats.median(); // 5.5
-const sum = stats.summate(); // 55
-
-// Erweiterte Statistiken
-const variance = stats.variance(); // 8.25
-const stdDev = stats.standardDeviation(); // 2.872
-const mode = stats.mode(); // Irgendein Wert (da alle einmal erscheinen)
-const q1 = stats.quantile(0.25); // 3.25
-const q3 = stats.quantile(0.75); // 7.75
-const iqr = stats.interquartileRange(); // 4.5
-
-// Häufigkeitsverteilung
-const freq = stats.frequency(); // Map {1 => 1n, 2 => 1n, ...}
+// Wenn Elementreihenfolge beibehalten werden muss
+const ordered = data
+    .sorted(comparator) // Sortierung überschreibt Umleitungseffekte
+    .toOrdered(); // Beibehaltung der Reihenfolge
 ```
 
-#### Spezifische Statistische Implementierungsklassen
-
-**NumericStatistics<E>**
-- Verarbeitet number-Typ statistische Analyse
-- Alle statistischen Berechnungen geben number-Typ zurück
-
-**BigIntStatistics<E>**
-- Verarbeitet bigint-Typ statistische Analyse
-- Alle statistischen Berechnungen geben bigint-Typ zurück
-
-**Code-Beispiel-Ergänzung:**
+### Fenster-Collector wählen (Fensteroperationen)
 ```typescript
-import { from } from 'semantic-typescript';
-
-// Numerische Statistiken
-const numberData = from([10, 20, 30, 40, 50]);
-const numericStats = numberData.toNumericStatistics();
-
-console.log(numericStats.mean()); // 30
-console.log(numericStats.summate()); // 150
-
-// Big Integer Statistiken
-const bigintData = from([100n, 200n, 300n, 400n, 500n]);
-const bigintStats = bigintData.toBigIntStatistics();
-
-console.log(bigintStats.mean()); // 300n
-console.log(bigintStats.summate()); // 1500n
+// Bei Fensteroperationsbedarf
+const windowed = data
+    .toWindow()
+    .slide(5n, 2n); // Gleitendes Fenster
+```
 
-// Statistiken mit Mapper-Funktionen
-const objectData = from([
-    { value: 15 },
-    { value: 25 },
-    { value: 35 },
-    { value: 45 }
-]);
+### Statistische Analyse wählen (Numerische Berechnungen)
+```typescript
+// Bei statistischem Analysebedarf
+const stats = data
+    .toNumericStatistics(); // Numerische Statistik
 
-const objectStats = objectData.toNumericStatistics();
-const meanWithMapper = objectStats.mean(obj => obj.value); // 30
-const sumWithMapper = objectStats.summate(obj => obj.value); // 120
+const bigIntStats = data
+    .toBigintStatistics(); // BigInt-Statistik
 ```
 
-## Vollständiges Verwendungsbeispiel
+[GitHub](https://github.com/eloyhere/semantic-typescript)
+[NPMJS](https://www.npmjs.com/package/semantic-typescript)
 
-```typescript
-import { from, validate, invalidate } from 'semantic-typescript';
-
-// 1. Erstelle Datenstrom
-const rawData = [5, 2, 8, 1, null, 9, 3, undefined, 7, 4, 6];
-const semanticStream = from(rawData);
-
-// 2. Stream-Verarbeitungspipeline
-const processedStream = semanticStream
-    .filter(val => validate(val)) // Filtere null und undefined heraus
-    .map(val => val! * 2) // Multipliziere jeden Wert mit 2 (verwende !, da validate sicherstellt, dass nicht leer)
-    .distinct(); // Entferne Duplikate
-
-// 3. Konvertiere zu Collectable und verwende Terminaloperationen
-const collectable = processedStream.toUnordered();
-
-// 4. Datenvalidierung und Verwendung
-if (!collectable.isEmpty()) {
-    const results = collectable
-        .filter(x => x > 5) // Filtere erneut
-        .toArray(); // Konvertiere zu Array
-    
-    console.log("Verarbeitungsergebnisse:", results); // [16, 18, 14, 8, 12]
-    
-    // Statistische Informationen
-    const stats = processedStream.toNumericStatistics();
-    console.log("Mittelwert:", stats.mean()); // 11.2
-    console.log("Gesamtsumme:", stats.summate()); // 56
-}
+## Wichtige Hinweise
 
-// 5. Behandle potenziell ungültige Daten
-const potentiallyInvalidData: Array<number | null> = [1, null, 3, 4, null];
-const validData = potentiallyInvalidData.filter(validate);
-const invalidData = potentiallyInvalidData.filter(invalidate);
-
-console.log("Gültige Daten:", validData); // [1, 3, 4]
-console.log("Ungültige Daten:", invalidData); // [null, null]
-```
+1. **Auswirkungen von Sortieroperationen**: In geordneten Collectors überschreibt `sorted()` die Effekte von `redirect`, `translate`, `shuffle`, `reverse`
+2. **Leistungsüberlegungen**: Bei fehlender Reihenfolgeanforderung priorisiert `toUnoredered()` verwenden
+3. **Speichernutzung**: Sortieroperationen benötigen O(n) zusätzlichen Speicher
+4. **Echtzeitdaten**: Semantic-Streams eignen sich für Echtzeitdaten und unterstützen asynchrone Datenquellen
 
-## Wichtige Verwendungsregeln Zusammenfassung
-
-1. **Erstelle Stream**: Verwende `from()`, `range()`, `fill()` etc. Factory-Methoden, um Semantic-Instanzen zu erstellen
-2. **Stream-Transformation**: Rufe `map()`, `filter()`, `distinct()` etc. Methoden auf Semantic-Instanzen auf
-3. **Konvertiere zu Collectable**: Muss eine der folgenden Methoden durch Semantic-Instanz aufrufen:
-   - `toOrdered()` - Geordneter Collector
-   - `toUnordered()` - Ungeordneter Collector (schnellste)
-   - `toWindow()` - Fenster-Collector
-   - `toNumericStatistics()` - Numerische Statistiken
-   - `toBigIntStatistics()` - Big Integer Statistiken
-   - `sorted()` - Natürliche Sortierung
-   - `sorted(comparator)` - Benutzerdefinierte Sortierung
-4. **Terminaloperationen**: Rufe `toArray()`, `count()`, `summate()` etc. Terminalmethoden auf Collectable-Instanzen auf
-5. **Datenvalidierung**: Verwende `validate()` um sicherzustellen, dass Daten nicht null/undefined sind, verwende `invalidate()` um ungültige Daten zu prüfen
-
-Dieses Design gewährleistet Typsicherheit und Leistungsoptimierung, während es gleichzeitig reichhaltige Stream-Verarbeitungsfunktionalität bietet.
+Diese Bibliothek bietet TypeScript-Entwicklern leistungsstarke und flexible Stream-Verarbeitungsfähigkeiten, die die Vorteile der funktionalen Programmierung mit Typsicherheit kombinieren.