semantic-typescript 0.2.6 → 0.2.9

package/readme.de.md

@@ -1,10 +1,10 @@
-# Semantic-TypeScript Stream-Verarbeitungsbibliothek
+# Semantic-TypeScript Stream Processing Library
 
-## Einführung
+## Einleitung
 
-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.
+Semantic-TypeScript ist eine moderne Stream-Verarbeitungsbibliothek, inspiriert von JavaScript GeneratorFunction, Java Stream und MySQL Index. Seine Kernphilosophie basiert auf dem Aufbau effizienter Datenverarbeitungspipelines mit Hilfe von Datenindizierung und bietet eine typsichere, funktionsbasierte Streaming-Benutzererfahrung für Frontend-Entwicklung.
 
-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.
+Im Gegensatz zur traditionellen synchronen Verarbeitung verwendet Semantic ein asynchrones Verarbeitungsmodell. Beim Erstellen eines Datenstroms hängt die Zeit, zu der das Terminal Daten empfängt, vollständig davon ab, wann der Upstream die `accept`- und `interrupt`-Callback-Funktionen aufruft. Dieses Design ermöglicht es der Bibliothek, Echtzeitdatenströme, große Datensätze und asynchrone Datenquellen elegant zu verarbeiten.
 
 ## Installation
 
@@ -12,393 +12,405 @@ Im Gegensatz zur traditionellen synchronen Verarbeitung verwendet Semantic einen
 npm install semantic-typescript
 ```
 
-## Grundtypen
+## Grundlegende Typen
 
 | Typ | Beschreibung |
 |------|-------------|
-| `Invalid<T>` | Ein Typ, der null oder undefined erweitert |
-| `Valid<T>` | Ein Typ, der null und undefined ausschließt |
-| `MaybeInvalid<T>` | Ein Typ, der null oder undefined sein kann |
-| `Primitive` | Sammlung von primitiven Typen |
-| `MaybePrimitive<T>` | Ein Typ, der ein primitiver Typ sein kann |
-| `OptionalSymbol` | Symbolkennung der Klasse Optional |
-| `SemanticSymbol` | Symbolkennung der Klasse Semantic |
-| `CollectorsSymbol` | Symbolkennung der Klasse Collector |
-| `CollectableSymbol` | Symbolkennung der Klasse Collectable |
-| `OrderedCollectableSymbol` | Symbolkennung der Klasse OrderedCollectable |
-| `WindowCollectableSymbol` | Symbolkennung der Klasse WindowCollectable |
-| `StatisticsSymbol` | Symbolkennung der Klasse Statistics |
-| `NumericStatisticsSymbol` | Symbolkennung der Klasse NumericStatistics |
-| `BigIntStatisticsSymbol` | Symbolkennung der Klasse BigIntStatistics |
-| `UnorderedCollectableSymbol` | Symbolkennung der Klasse UnorderedCollectable |
-
-## Funktionale Schnittstellen
+| `Invalid<T>` | Typ, der sich von `null` oder `undefined` ableitet |
+| `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 primitiver Typ sein kann |
+| `OptionalSymbol` | Symbolbezeichner der `Optional`-Klasse |
+| `SemanticSymbol` | Symbolbezeichner der `Semantic`-Klasse |
+| `CollectorsSymbol` | Symbolbezeichner der `Collector`-Klasse |
+| `CollectableSymbol` | Symbolbezeichner der `Collectable`-Klasse |
+| `OrderedCollectableSymbol` | Symbolbezeichner der `OrderedCollectable`-Klasse |
+| `WindowCollectableSymbol` | Symbolbezeichner der `WindowCollectable`-Klasse |
+| `StatisticsSymbol` | Symbolbezeichner der `Statistics`-Klasse |
+| `NumericStatisticsSymbol` | Symbolbezeichner der `NumericStatistics`-Klasse |
+| `BigIntStatisticsSymbol` | Symbolbezeichner der `BigIntStatistics`-Klasse |
+| `UnorderedCollectableSymbol` | Symbolbezeichner der `UnorderedCollectable`-Klasse |
+
+## Funktionsorientierte Schnittstellen
 
 | Schnittstelle | Beschreibung |
-|---------------|-------------|
-| `Runnable` | Funktion ohne Parameter und Rückgabewert |  
-| `Supplier<R>` | Funktion ohne Parameter, gibt R zurück |  
-| `Functional<T, R>` | Einzelparameter-Konvertierungsfunktion |
-| `BiFunctional<T, U, R>` | Zweiparameter-Konvertierungsfunktion |
-| `TriFunctional<T, U, V, R>` | Dreiparameter-Konvertierungsfunktion |
-| `Predicate<T>` | Einzelparameter-Auswahlfunktion |
-| `BiPredicate<T, U>` | Zweiparameter-Auswahlfunktion |
-| `TriPredicate<T, U, V>` | Dreiparameter-Auswahlfunktion |
-| `Consumer<T>` | Einzelparameter-Verarbeitungsfunktion |
-| `BiConsumer<T, U>` | Zweiparameter-Verarbeitungsfunktion |
-| `TriConsumer<T, U, V>` | Dreiparameter-Verarbeitungsfunktion |
+|-----------|-------------|
+| `Runnable` | Funktion ohne Parameter und ohne Rückgabewert |  
+| `Supplier<R>` | Funktion ohne Parameter, die `R` zurückgibt |  
+| `Functional<T, R>` | Einzelparameter-Transformationsfunktion |
+| `BiFunctional<T, U, R>` | Zweiparameter-Transformationsfunktion |
+| `TriFunctional<T, U, V, R>` | Dreiparameter-Transformationsfunktion |
+| `Predicate<T>` | Einzelparameter-Prädikatfunktion |
+| `BiPredicate<T, U>` | Zweiparameter-Prädikatfunktion |
+| `TriPredicate<T, U, V>` | Dreiparameter-Prädikatfunktion |
+| `Consumer<T>` | Einzelparameter-Consumerfunktion |
+| `BiConsumer<T, U>` | Zweiparameter-Consumerfunktion |
+| `TriConsumer<T, U, V>` | Dreiparameter-Consumerfunktion |
 | `Comparator<T>` | Zweiparameter-Vergleichsfunktion |
 | `Generator<T>` | Generatorfunktion (Kern und Basis) |
 
 ```typescript
-// Typverwendungsbeispiele
-const predicate: Predicate<number> = (n) => n > 0;
-const mapper: Functional<string, number> = (str) => str.length;
-const comparator: Comparator<number> = (a, b) => a - b;
+// Beispiel für die Verwendung von Typen
+let predicate: Predicate<number> = (n: number): boolean => n > 0;
+let mapper: Functional<string, number> = (text: string): number => text.length;
+let comparator: Comparator<number> = (a: number, b: number): number => a - b;
 ```
 
-## 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) |
+## Typguards
+
+| Funktion | Beschreibung | Zeitkomplexität | Speicherplatzkomplexität |
+|------|------|------------|------------|
+| `validate<T>(t: MaybeInvalid<T>): t is T` | Überprüft, ob der Wert nicht null oder undefined ist | O(1) | O(1) |
+| `invalidate<T>(t: MaybeInvalid<T>): t is null \| undefined` | Überprüft, ob der Wert null oder undefined ist | O(1) | O(1) |
+| `isBoolean(t: unknown): t is boolean` | Überprüft, ob es sich um einen booleschen Wert handelt | O(1) | O(1) |
+| `isString(t: unknown): t is string` | Überprüft, ob es sich um einen String handelt | O(1) | O(1) |
+| `isNumber(t: unknown): t is number` | Überprüft, ob es sich um eine Zahl handelt | O(1) | O(1) |
+| `isFunction(t: unknown): t is Function` | Überprüft, ob es sich um eine Funktion handelt | O(1) | O(1) |
+| `isObject(t: unknown): t is object` | Überprüft, ob es sich um ein Objekt handelt | O(1) | O(1) |
+| `isSymbol(t: unknown): t is symbol` | Überprüft, ob es sich um ein Symbol handelt | O(1) | O(1) |
+| `isBigint(t: unknown): t is bigint` | Überprüft, ob es sich um ein BigInt handelt | O(1) | O(1) |
+| `isPrimitive(t: unknown): t is Primitive` | Überprüft, ob es sich um einen primitiven Typ handelt | O(1) | O(1) |
+| `isIterable(t: unknown): t is Iterable<unknown>` | Überprüft, ob es sich um ein iterierbares Objekt handelt | O(1) | O(1) |
+| `isOptional(t: unknown): t is Optional<unknown>` | Überprüft, ob es sich um eine Optional-Instanz handelt | O(1) | O(1) |
+| `isSemantic(t: unknown): t is Semantic<unknown>` | Überprüft, ob es sich um eine Semantic-Instanz handelt | O(1) | O(1) |
+| `isCollector(t: unknown): t is Collector<unknown, unknown, unknown>` | Überprüft, ob es sich um eine Collector-Instanz handelt | O(1) | O(1) |
+| `isCollectable(t: unknown): t is Collectable<unknown>` | Überprüft, ob es sich um eine Collectable-Instanz handelt | O(1) | O(1) |
+| `isOrderedCollectable(t: unknown): t is OrderedCollectable<unknown>` | Überprüft, ob es sich um eine OrderedCollectable-Instanz handelt | O(1) | O(1) |
+| `isWindowCollectable(t: unknown): t is WindowCollectable<unknown>` | Überprüft, ob es sich um eine WindowCollectable-Instanz handelt | O(1) | O(1) |
+| `isUnorderedCollectable(t: unknown): t is UnorderedCollectable<unknown>` | Überprüft, ob es sich um eine UnorderedCollectable-Instanz handelt | O(1) | O(1) |
+| `isStatistics(t: unknown): t is Statistics<unknown, number \| bigint>` | Überprüft, ob es sich um eine Statistics-Instanz handelt | O(1) | O(1) |
+| `isNumericStatistics(t: unknown): t is NumericStatistics<unknown>` | Überprüft, ob es sich um eine NumericStatistics-Instanz handelt | O(1) | O(1) |
+| `isBigIntStatistics(t: unknown): t is BigIntStatistics<unknown>` | Überprüft, ob es sich um eine BigIntStatistics-Instanz handelt | O(1) | O(1) |
+| `isPromise(t: unknown): t is Promise<unknown>` | Überprüft, ob es sich um ein Promise-Objekt handelt | O(1) | O(1) |
+| `isAsync(t: unknown): t is AsyncFunction` | Überprüft, ob es sich um eine AsyncFunction handelt | O(1) | O(1) |
 
 ```typescript
-// Typwächter-Verwendungsbeispiele
-const value: unknown = "hello";
+// Beispiel für die Verwendung von Typguards
+let value: unknown = "hello";
 
 if (isString(value)) {
-    console.log(value.length); // Typsicher, value wird als string inferiert
+    console.log(value.length); // Typsicher, value wird als string abgeleitet
 }
 
 if (isOptional(someValue)) {
-    someValue.ifPresent(val => console.log(val));
+    someValue.ifPresent((value): void => console.log(val));
+}
+
+if(isIterable(value)){
+    // Typsicher, jetzt ist es ein iterierbares Objekt.
+    for(let item of value){
+        console.log(item);
+    }
 }
 ```
 
 ## Hilfsfunktionen
 
-| Funktion | Beschreibung | Zeitkomplexität | Raumkomplexität |
-|----------|-------------|-----------------|-----------------|
+| Funktion | Beschreibung | Zeitkomplexität | Speicherplatzkomplexitä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) |
 
 ```typescript
-// Hilfsfunktions-Verwendungsbeispiele
-const numbers = [3, 1, 4, 1, 5];
+// Beispiel für die Verwendung von Hilfsfunktionen
+let numbers: Array<number> = [3, 1, 4, 1, 5];
 numbers.sort(useCompare); // [1, 1, 3, 4, 5]
 
-const randomNum = useRandom(42); // Seed-basierte Zufallszahl
-const randomBigInt = useRandom(1000n); // BigInt-Zufallszahl
+let randomNum = useRandom(42); // Saat-basierter Zufallszahl
 ```
 
 ## Fabrikmethoden
 
-### Optional-Fabrikmethoden
+### Optionale Fabrikmethoden
 
-| 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) |
+| Methode | Beschreibung | Zeitkomplexität | Speicherplatzkomplexität |
+|------|------|------------|------------|
+| `Optional.empty<T>()` | Erstellt eine leere Optional | O(1) | O(1) |
+| `Optional.of<T>(value)` | Erstellt eine Optional, die einen Wert enthält | O(1) | O(1) |
+| `Optional.ofNullable<T>(value)` | Erstellt eine potenziell leere Optional | O(1) | O(1) |
+| `Optional.ofNonNull<T>(value)` | Erstellt eine nicht-null Optional | O(1) | O(1) |
 
 ```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
+// Beispiele für die Verwendung von Optional
+let empty: Optional<number> = Optional.empty();
+let present: Optional<number> = Optional.of(42);
+let nullable: Optional<string> = Optional.ofNullable<string>(null);
+let nonNull: Optional<string> = Optional.ofNonNull("hello");
+
+present.ifPresent((value: number): void => console.log(value)); // Gibt 42 aus
+console.log(empty.get(100)); // Gibt 100 aus
 ```
 
-### Collector-Fabrikmethoden
+### Collector Fabrikmethoden
 
-| 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) |
+| Methode | Beschreibung | Zeitkomplexität | Speicherplatzkomplexität |
+|------|------|------------|------------|
+| `Collector.full(identity, accumulator, finisher)` | Erstellt einen vollständigen Collector | O(1) | O(1) |
+| `Collector.shortable(identity, interruptor, accumulator, finisher)` | Erstellt einen unterbrechbaren Collector | O(1) | O(1) |
 
 ```typescript
-// Beispiele für Collector-Konvertierung
-const numbers = from([3, 1, 4, 1, 5, 9, 2, 6, 5]);
+// Beispiele für die Konvertierung von Collectors
+let numbers: Semantic<number> = from([3, 1, 4, 1, 5, 9, 2, 6, 5]);
 
-// Leistung zuerst: Verwende ungeordneten Collector
-const unordered = numbers
-    .filter(n => n > 3)
-    .toUnoredered();
+// Leistung zuerst: verwenden Sie den ungeordneten Collector
+let unordered: UnorderedCollectable<number> = from([3, 1, 4, 1, 5, 9, 2, 6, 5])
+    .filter((n: number): boolean => n > 3)
+    .toUnordered();
 
-// Sortierung benötigt: Verwende geordneten Collector  
-const ordered = numbers.sorted();
+// Sortierung erforderlich: verwenden Sie den geordneten Collector  
+let ordered: OrderedCollectable<number> = from([3, 1, 4, 1, 5, 9, 2, 6, 5])
+    .sorted();
 
 // Zählt die Anzahl der Elemente
-let count = Collector.full(
-    () => 0, // Anfangswert
-    (accumulator, element) => accumulator + element, // Akkumulieren
-    (accumulator) => accumulator // Abschluss
+let count: Collector<number, number, number> = Collector.full(
+    (): number => 0, // Anfangswert
+    (accumulator: number, element: number): number => accumulator + element, // Akkumulieren
+    (accumulator: number): number => accumulator // Fertigstellen
 );
 count.collect(from([1,2,3,4,5])); // Zählt aus einem Stream
-count.collect([1,2,3,4,5]); // Zählt aus einem Iterable-Objekt
+count.collect([1,2,3,4,5]); // Zählt aus einem iterierbaren Objekt
 
-let find = Collector.shortable(
-    () => Optional.empty(), // Anfangswert
-    (element, index, accumulator) => accumulator.isPresent(), // Unterbrechen
-    (accumulator, element, index) => Optional.of(element), // Akkumulieren
-    (accumulator) => accumulator // Abschluss
+let find: Optional<number> = Collector.shortable(
+    (): Optional<number> => Optional.empty(), // Anfangswert
+    (element: number, index: bigint, accumulator: Optional<number>): Optional<number> => accumulator.isPresent(), // Unterbrechen
+    (accumulator: Optional<number>, element: number, index: bigint): Optional<number> => Optional.of(element), // Akkumulieren
+    (accumulator: Optional<number>): Optional<number> => accumulator // Fertigstellen
 );
 find.collect(from([1,2,3,4,5])); // Findet das erste Element
 find.collect([1,2,3,4,5]); // Findet das erste Element
 ```
 
-### Semantic-Fabrikmethoden
+### Semantic Fabrikmethoden
 
-| 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) |
-| `generate<E>(element, interrupt)` | Erzeugt Stream mit Generatorfunktion | 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) |
+| Methode | Beschreibung | Zeitkomplexität | Speicherplatzkomplexität |
+|------|------|------------|------------|
+| `animationFrame(period: number, delay: number = 0)` | Erstellt einen zeitgesteuerten Animationsframe-Stream | O(1)* | O(1) |
+| `blob(blob, chunkSize)` | Erstellt einen Stream aus einem Blob | O(n) | O(chunkSize) |
+| `empty<E>()` | Erstellt einen leeren Stream | O(1) | O(1) |
+| `fill<E>(element, count)` | Erstellt einen gefüllten Stream | O(n) | O(1) |
+| `from<E>(iterable)` | Erstellt einen Stream aus einem iterierbaren Objekt | O(1) | O(1) |
+| `interval(period, delay?)` | Erstellt einen zeitgesteuerten Intervall-Stream | O(1)* | O(1) |
+| `iterate<E>(generator)` | Erstellt einen Stream aus einem Generator | O(1) | O(1) |
+| `range(start, end, step)` | Erstellt einen numerischen Bereichs-Stream | O(n) | O(1) |
+| `websocket(websocket)` | Erstellt einen Stream aus einem WebSocket | O(1) | O(1) |
 
 ```typescript
-// Beispiel zur Verwendung der Semantic-Fabrikmethoden
+// Beispiele für die Verwendung von Semantic Fabrikmethoden
+
+// Erstellt einen Stream aus einem zeitgesteuerten Animationsframe
+animationFrame(1000)
+    .toUnordered()
+    .forEach(frame => console.log(frame));
 
-// Stream aus Blob erzeugen (chunkweises Lesen)
+// Erstellt einen Stream aus einem Blob (chunked reading)
 blob(someBlob, 1024n)
-  .toUnordered()
-  .write(WritableStream)
-  .then(callback) // Stream-Schreibvorgang erfolgreich
-  .catch(writeFi); // Stream-Schreibvorgang fehlgeschlagen
+    .toUnordered()
+    .write(WritableStream)
+    .then(callback) // Schreiben des Streams erfolgreich
+    .catch(callback); // Schreiben des Streams fehlgeschlagen
 
-// Leeren Stream erzeugen, der erst nach Verknüpfung mit anderen Streams ausgeführt wird
+// Erstellt einen leeren Stream, der erst ausgeführt wird, wenn er mit anderen Streams verkettet wird
 empty<string>()
-  .toUnordered()
-  .join(); //[]
+    .toUnordered()
+    .join(); //[]
 
-// Gefüllten Stream erzeugen
-const filledStream = fill("hello", 3); // "hello", "hello", "hello"
+// Erstellt einen gefüllten Stream
+let filledStream = fill("hello", 3); // "hello", "hello", "hello"
 
-// 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);
+// Erstellt einen zeitgesteuerten Stream mit einer anfänglichen Verzögerung von 2 Sekunden und einer Ausführungsperiode von 5 Sekunden, implementiert auf der Grundlage eines Timer-Mechanismus; kann aufgrund von Systemplanungsgenauigkeitsbeschränkungen zu Zeitdrift führen.
+let intervalStream = interval(5000, 2000);
 
-// Stream aus iterierbarem Objekt erzeugen
-const numberStream = from([1, 2, 3, 4, 5]);
-const stringStream = from(new Set(["Alex", "Bob"]));
+// Erstellt einen Stream aus einem iterierbaren Objekt
+let numberStream = from([1, 2, 3, 4, 5]);
+let stringStream = from(new Set(["Alex", "Bob"]));
 
-// Bereichs-Stream erzeugen
-const rangeStream = range(1, 10, 2); // 1, 3, 5, 7, 9
+// Erstellt einen Bereichs-Stream
+let rangeStream = range(1, 10, 2); // 1, 3, 5, 7, 9
 
-// WebSocket-Ereignisstream
-const ws = new WebSocket("ws://localhost:8080");
+// WebSocket-Ereignis-Stream
+let 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
+  .filter((event): boolean => event.type === "message"); // Nur Nachrichtenereignisse abhören
+  .toUnordered() // Ereignisse sind in der Regel nicht geordnet
+  .forEach((event): void => receive(event)); // Nachrichten empfangen
 ```
 
-## Semantic-Klassenmethoden
+## Semantic Klassenmethoden
 
-| Methode | Beschreibung | Zeitkomplexität | Raumkomplexität |
-|---------|-------------|-----------------|-----------------|
+| Methode | Beschreibung | Zeitkomplexität | Speicherplatzkomplexitä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) |
+| `distinct(comparator)` | Entfernt Duplikate mit einem Vergleichsoperator | O(n²) | O(n) |
+| `dropWhile(predicate)` | Verwirft Elemente, die die Bedingung 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) |
+| `flat(mapper)` | Flachemapping | O(n × m) | O(1) |
+| `flatMap(mapper)` | Flachemapping in einen neuen Typ | O(n × m) | O(1) |
+| `limit(n)` | Begrenzt die Anzahl der Elemente | O(n) | O(1) |
+| `map(mapper)` | Zuordnungstransformation | O(n) | O(1) |
+| `peek(consumer)` | Blickt auf Elemente | O(n) | O(1) |
+| `redirect(redirector)` | Leitet den Index um | O(n) | O(1) |
+| `reverse()` | Umkehrt den Stream | O(n) | O(1) |
+| `shuffle()` | Mischt zufällig | O(n) | O(1) |
+| `shuffle(mapper)` | Mischt mit einem Mapper | O(n) | O(1) |
+| `skip(n)` | Überspringt die ersten 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) |
+| `sorted(comparator)` | Sortiert mit einem Vergleichsoperator | O(n log n) | O(n) |
+| `sub(start, end)` | Holt einen Substream | O(n) | O(1) |
+| `takeWhile(predicate)` | Holt Elemente, die die Bedingung erfüllen | O(n) | O(1) |
+| `translate(offset)` | Übersetzt den Index | O(n) | O(1) |
+| `translate(translator)` | Übersetzt den Index mit einem Translator | O(n) | O(1) |
 
 ```typescript
-// 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
+// Beispiele für Semantic-Operationen
+let result = from([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
+    .filter((n: number): boolean => n % 2 === 0)        // Filtert gerade Zahlen
+    .map((n: number): number => n * 2)                 // Multipliziert mit 2
+    .skip(1)                         // Überspringt das erste
     .limit(3)                        // Begrenzt auf 3 Elemente
-    .toUnordered()                    // Ungeordneten Collector verwenden
-    .toArray();                      // Konvertiert zu Array
+    .toUnordered()                   // Konvertiert in einen ungeordneten Collector
+    .toArray();                      // Konvertiert in ein 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
+// Komplexes Operationsexample
+let complexResult = range(1, 100, 1)
+    .flatMap((n: number): Semantics<number> => from([n, n * 2])) // Mappt jedes Element auf zwei
     .distinct()                      // Entfernt Duplikate
-    .shuffle()                       // Mischt zufällig
-    .takeWhile(n => n < 50)         // Nimmt Elemente < 50
-    .toOrdered()                     // Konvertiert zu geordnetem Collector
-    .toArray();                      // Konvertiert zu Array
+    .shuffle()                       // Mischt die Reihenfolge
+    .takeWhile((n: number): boolean => n < 50)         // Nimmt Elemente kleiner als 50
+    .toOrdered()                     // Konvertiert in einen geordneten Collector
+    .toArray();                      // Konvertiert in ein Array
 ```
 
-## Semantische Konversionsmethoden
+## Semantic Konvertierungsmethoden
 
-| Methode | Beschreibung | Zeitkomplexität | Platzkomplexität |
+| Methode | Beschreibung | Zeitkomplexität | Speicherplatzkomplexität |
 |------------|------------|------------|------------|
-| `sorted()` | In geordneten Collector umwandeln | O(n log n) | O(n) |
-| `toUnordered()` | In ungeordneten Collector umwandeln | O(1) | O(1) |
-| `toOrdered()` | In geordneten Collector umwandeln | O(1) | O(1) |
-| `toNumericStatistics()` | In numerische Statistik umwandeln | O(n) | O(1) |
-| `toBigintStatistics()` | In BigInt-Statistik umwandeln | O(n) | O(1) |
-| `toWindow()` | In Window-Collector umwandeln | O(1) | O(1) |
-| `toCollectable()` | In `UnorderedCollectable` umwandeln | O(n) | O(1) |
-| `toCollectable(mapper)` | In benutzerdefinierten Collectable umwandeln | O(n) | O(1) |
+| `sorted()` | Konvertiert in einen geordneten Collector | O(n log n) | O(n) |
+| `toUnordered()` | Konvertiert in einen ungeordneten Collector | O(1) | O(1) |
+| `toOrdered()` | Konvertiert in einen geordneten Collector | O(1) | O(1) |
+| `toNumericStatistics()` | Konvertiert in numerische Statistiken | O(n) | O(1) |
+| `toBigintStatistics()` | Konvertiert in BigInt-Statistiken | O(n) | O(1) |
+| `toWindow()` | Konvertiert in einen Fenstercollector | O(1) | O(1) |
+| `toCollectable()` | Konvertiert in `UnorderdCollectable` | O(n) | O(1) |
+| `toCollectable(mapper)` | Konvertiert in einen benutzerdefinierten Collectable | O(n) | O(1) |
 
 ```typescript
-// In ein aufsteigend sortiertes Array umwandeln
+// Konvertiert in ein aufsteigend sortiertes Array
 from([6,4,3,5,2]) // Erstellt einen Stream
     .sorted() // Sortiert den Stream in aufsteigender Reihenfolge
     .toArray(); // [2, 3, 4, 5, 6]
 
-// In ein absteigend sortiertes Array umwandeln
+// Konvertiert in ein absteigend sortiertes Array
 from([6,4,3,5,2]) // Erstellt einen Stream
-    .soted((a, b) => b - a) // Sortiert den Stream in absteigender Reihenfolge
+    .soted((a: number, b: number): number => b - a) // Sortiert den Stream in absteigender Reihenfolge
     .toArray(); // [6, 5, 4, 3, 2]
 
-// Umleiten zu einem umgekehrten Array
+// Leitet um in ein umgekehrtes Array
 from([6,4,3,5,2])
-    .redirect((element, index) => -index) // Leitet in umgekehrter Reihenfolge um
+    .redirect((element, index): bigint => -index) // Leitet um in umgekehrter Reihenfolge
     .toOrderd() // Behält die umgeleitete Reihenfolge bei
     .toArray(); // [2, 5, 3, 4, 6]
 
-// Umleitungen zum Umkehren des Arrays ignorieren
+// Ignoriert Umleitungen, um ein umgekehrtes Array zu erhalten
 from([6,4,3,5,2])
-    .redirect((element, index) => -index) // Leitet in umgekehrter Reihenfolge um
-    .toUnorderd() // Verwirft die umgeleitete Reihenfolge. Diese Operation ignoriert die Operationen `redirect`, `reverse`, `shuffle` und `translate`
+    .redirect((element: number, index: bigint) => -index) // Leitet um in umgekehrter Reihenfolge
+    .toUnorderd() // Ignoriert die umgeleitete Reihenfolge. Diese Operation ignoriert `redirect`, `reverse`, `shuffle` und `translate` Operationen
     .toArray(); // [2, 5, 3, 4, 6]
 
-// Den Stream umkehren und in ein Array umwandeln
+// Kehrt den Stream in ein Array um
 from([6, 4, 3, 5, 2])
     .reverse() // Kehrt den Stream um
     .toOrdered() // Garantiert die umgekehrte Reihenfolge
     .toArray(); // [2, 5, 3, 4, 6]
 
-// Den gemischten Stream überschreiben und in ein Array umwandeln
+// Überschreibt den gemischten Stream in ein Array
 from([6, 4, 3, 5, 2])
     .shuffle() // Mischt den Stream
-    .sorted() // Überschreibt die gemischte Reihenfolge. Diese Operation überschreibt die Operationen `redirect`, `reverse`, `shuffle` und `translate`
+    .sorted() // Überschreibt die gemischte Reihenfolge. Diese Operation überschreibt `redirect`, `reverse`, `shuffle` und `translate` Operationen
     .toArray(); // [2, 5, 3, 4, 6]
 
-// In Window-Collector umwandeln
+// Konvertiert in einen Fenstercollector
 from([6, 4, 3, 5, 2]).toWindow();
 
-// In numerische Statistik umwandeln
+// Konvertiert in numerische Statistiken
 from([6, 4, 3, 5, 2]).toNumericStatistics();
 
-// In BigInt-Statistik umwandeln
+// Konvertiert in BigInt-Statistiken
 from([6n, 4n, 3n, 5n, 2n]).toBigintStatistics();
 
-// Definiert einen benutzerdefinierten Collector zur Datensammlung
+// Definiert einen benutzerdefinierten Collector zum Sammeln von Daten
 let customizedCollector = from([1, 2, 3, 4, 5]).toCollectable((generator: Generator<E>) => new CustomizedCollector(generator));
 ```
 
-## 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) |
+## Collectable Auflistungsmethoden
+
+| Methode | Beschreibung | Zeitkomplexität | Speicherplatzkomplexität |
+|------|------|------------|------------|
+| `anyMatch(predicate)` | Ob irgendein Element übereinstimmt | O(n) | O(1) |
+| `allMatch(predicate)` | Ob alle Elemente übereinstimmen | O(n) | O(1) |
+| `count()` | Elementanzahl | O(n) | O(1) |
+| `isEmpty()` | Ob es leer ist | O(1) | O(1) |
+| `findAny()` | Finde ein beliebiges Element | O(n) | O(1) |
+| `findFirst()` | Finde das erste Element | O(n) | O(1) |
+| `findLast()` | Finde das letzte Element | O(n) | O(1) |
+| `forEach(action)` | Durchlaufe alle Elemente | O(n) | O(1) |
+| `group(classifier)` | Gruppiere nach Klassifizierer | O(n) | O(n) |
+| `groupBy(keyExtractor, valueExtractor)` | Gruppiere nach Schlüssel-Wert-Extraktor | O(n) | O(n) |
+| `join()` | Verbinde als Zeichenkette | O(n) | O(n) |
+| `join(delimiter)` | Verbinde mit einem Trennzeichen | O(n) | O(n) |
+| `nonMatch(predicate)` | Ob kein Element übereinstimmt | O(n) | O(1) |
+| `partition(count)` | Partitioniere nach Anzahl | O(n) | O(n) |
+| `partitionBy(classifier)` | Partitioniere nach Klassifizierer | 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) |
+| `reduce(identity, accumulator)` | Reduzierung mit Anfangswert | O(n) | O(1) |
+| `toArray()` | Konvertiere in ein Array | O(n) | O(n) |
+| `toMap(keyExtractor, valueExtractor)` | Konvertiere in eine Map | O(n) | O(n) |
+| `toSet()` | Konvertiere in eine Menge | O(n) | O(n) |
+| `write(stream)` | Schreibe in einen Stream | O(n) | O(1) |
 
 ```typescript
-// Collectable-Operationsbeispiele
-const data = from([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
-    .filter(n => n % 2 === 0)
+// Collectable Operationsexamples
+let data = from([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
+    .filter((n: number): boolean => n % 2 === 0)
     .toOrdered();
 
-// Übereinstimmungsprüfungen
-console.log(data.anyMatch(n => n > 5)); // true
-console.log(data.allMatch(n => n < 20)); // true
+// Übereinstimmungsüberprüfungen
+console.log(data.anyMatch((n: number): boolean => n > 5)); // true
+console.log(data.allMatch((n: number): boolean => n < 20)); // true
 
-// Suchoperationen
-data.findFirst().ifPresent(n => console.log(n)); // 2
-data.findAny().ifPresent(n => console.log(n)); // Beliebiges Element
+// Suchvorgänge
+data.findFirst().ifPresent((n: number): void => console.log(n)); // 2
+data.findAny().ifPresent((n: number): void => console.log(n)); // Ein beliebiges Element
 
-// Gruppierungsoperationen
-const grouped = data.groupBy(
-    n => n > 5 ? "large" : "small",
-    n => n * 2
-);
-// {small: [4, 8], large: [12, 16, 20]}
+// Gruppierungsvorgänge
+let grouped = data.groupBy(
+    (n: number): string => (n > 5 ? "groß" : "klein"),
+    (n: number): number => n * 2
+); // {klein: [4, 8], groß: [12, 16, 20]}
 
-// Reduktionsoperationen
-const sum = data.reduce(0, (acc, n) => acc + n); // 30
+// Reduktionsvorgänge
+let sum = data.reduce(0, (acc, n) => acc + n); // 30
 
 // Ausgabeoperationen
-data.join(", "); // "2, 4, 6, 8, 10"
+data.join(", "); // "[2, 4, 6, 8, 10]"
 ```
 
-## Statistische Analysemethoden
+## Statistische Analysemethode
 
-### NumericStatistics-Methoden
+### NumericStatistics Methoden
 
-| Methode | Beschreibung | Zeitkomplexität | Raumkomplexität |
-|---------|-------------|-----------------|-----------------|
-| `range()` | Spannweite | O(n) | O(1) |
+| Methode | Beschreibung | Zeitkomplexität | Speicherplatzkomplexität |
+|------|------|------------|------------|
+| `range()` | Bereich | 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) |
+| `summate()` | Summation | 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) |
@@ -406,7 +418,7 @@ data.join(", "); // "2, 4, 6, 8, 10"
 
 ```typescript
 // Statistische Analysebeispiele
-const numbers = from([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
+let numbers = from([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
     .toNumericStatistics();
 
 console.log("Mittelwert:", numbers.mean()); // 5.5
@@ -414,51 +426,48 @@ 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([
+// Mit Mappern statistische Analyse durchführen
+let objects = from([
     { value: 10 },
     { value: 20 }, 
     { value: 30 }
 ]).toNumericStatistics();
-
 console.log("Gemappter Mittelwert:", objects.mean(obj => obj.value)); // 20
 ```
 
-## Leistungsauswahlleitfaden
+## Leistungsauswahlhandbuch
 
-### Ungeordneten Collector wählen (Leistungspriorität)
+### Wählen Sie einen ungeordneten Collector (Leistung zuerst)
 ```typescript
-// Wenn keine Reihenfolgegarantie benötigt wird
-const highPerformance = data
+// Wenn keine Reihenfolgegarantie benötigt wird, verwenden Sie einen ungeordneten Collector für beste Leistung
+let highPerformance = data
     .filter(predicate)
     .map(mapper)
-    .toUnoredered(); // Beste Leistung
+    .toUnordered(); // Beste Leistung
 ```
 
-### Geordneten Collector wählen (Reihenfolge benötigt)
+### Wählen Sie einen geordneten Collector (Reihenfolge erforderlich)
 ```typescript
-// Wenn Elementreihenfolge beibehalten werden muss
-const ordered = data
-    .sorted(comparator) // Sortierung überschreibt Umleitungseffekte
-    .toOrdered(); // Beibehaltung der Reihenfolge
+// Wenn die Reihenfolge der Elemente beibehalten werden muss, verwenden Sie einen geordneten Collector
+let ordered = data.sorted(comparator);
 ```
 
-### Fenster-Collector wählen (Fensteroperationen)
+### Wählen Sie einen Fenstercollector (Fensteroperationen)
 ```typescript
-// Bei Fensteroperationsbedarf
-const windowed = data
+// Wenn Fensteroperationen benötigt werden
+let window: WindowCollectable<number> = data
     .toWindow()
-    .slide(5n, 2n); // Gleitendes Fenster
+    .slide(5n, 2n); // Gleitender Fenster
 ```
 
-### Statistische Analyse wählen (Numerische Berechnungen)
+### Wählen Sie eine statistische Analyse (numerische Berechnungen)
 ```typescript
-// Bei statistischem Analysebedarf
-const stats = data
-    .toNumericStatistics(); // Numerische Statistik
+// Wenn eine statistische Analyse benötigt wird
+let statistics: NumericStatistics<number> = data
+    .toNumericStatistics(); // Numerische Statistiken
 
-const bigIntStats = data
-    .toBigintStatistics(); // BigInt-Statistik
+let bigIntStatistics: BigintStatistics<bigint> = data
+    .toBigintStatistics(); // Große Ganzzahlstatistiken
 ```
 
 [GitHub](https://github.com/eloyhere/semantic-typescript)
@@ -466,9 +475,9 @@ const bigIntStats = data
 
 ## Wichtige Hinweise
 
-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
+1. **Auswirkungen von Sortiervorgängen**: In geordneten Collectors überschreibt der `sorted()`-Vorgang die Effekte von `redirect`, `translate`, `shuffle`, `reverse`.
+2. **Leistungserwägungen**: Wenn keine Reihenfolgegarantie benötigt wird, bevorzugen Sie die Verwendung von `toUnordered()` für eine bessere Leistung.
+3. **Speicherverwendung**: Sortiervorgänge erfordern zusätzlichen Speicherplatz von O(n).
+4. **Echtzeitdaten**: Semantic-Streams eignen sich für die Verarbeitung von Echtzeitdaten und unterstützen asynchrone Datenquellen.
 
-Diese Bibliothek bietet TypeScript-Entwicklern leistungsstarke und flexible Stream-Verarbeitungsfähigkeiten, die die Vorteile der funktionalen Programmierung mit Typsicherheit kombinieren.
+Diese Bibliothek bietet TypeScript-Entwicklern leistungsstarke und flexible Streaming-Fähigkeiten und kombiniert die Vorteile der funktionalen Programmierung mit Typsicherheitsgarantien.