====== Lyx – Arrays & Maps ======

Lyx bietet effiziente Wege, um Datenmengen zu verwalten. Arrays sind auf maximale Performance und Vorhersehbarkeit ausgelegt, während Maps flexible Schlüssel-Wert-Paare ermöglichen.

===== 1) Arrays (Indizierte Listen) =====

In Lyx sind Arrays dynamisch und werden auf dem Heap verwaltet. Sie speichern ihre Länge und Kapazität direkt mit dem Pointer ("Fat Pointer"), was sie sicherer als reine C-Arrays macht.

==== Deklaration und Initialisierung ====
<code lyx>
// Ein leeres Array für Ganzzahlen
var numbers: array<int64>;

// Initialisierung mit Werten (Literal)
var primes: array<int64> := [2, 3, 5, 7, 11];
</code>

==== Operationen (Builtins) ====
Lyx bietet hocheffiziente Builtins für die Arbeit mit Arrays:

.len(): Gibt die Anzahl der Elemente zurück.

.push(val): Fügt ein Element am Ende hinzu (vergrößert das Array bei Bedarf).

.pop(): Entfernt und liefert das letzte Element.

.clear(): Leert das Array, behält aber den reservierten Speicher.

<code lyx>
primes.push(13);
let size := primes.len(); // 6
</code>

===== 2) Mehrdimensionale Arrays & Matrizen =====

Lyx unterstützt geschachtelte Arrays. Da diese jedoch "Arrays von Arrays" sind, liegen die Zeilen nicht zwingend hintereinander im Speicher.

<code lyx>
var matrix: array<array<int64>>;
// Zugriff: matrix[y][x]
</code>

===== 3) Maps (Assoziative Speicher) =====

Maps (auch Hash-Tabellen oder Wörterbücher genannt) sind in der Unit std.List (oder spezifisch std.Map) definiert. Sie erlauben den Zugriff über einen Schlüssel (z. B. einen String).

Import: import std.List;

<code lyx>
var scores: Map<pchar, int64> := Map.Create();

scores.Set("Player1", 1500);
scores.Set("Player2", 1250);

let s := scores.Get("Player1"); // 1500
</code>

==== Performance-Hinweis ====

Arrays: O(1) Zugriff über den Index. Ideal für CPU-Caches.

Maps: O(1) im Durchschnitt, aber langsamer als Arrays wegen der Hash-Berechnung.

===== 4) Parallel Arrays (SIMD-Optimierung) =====

Ein besonderes Feature von Lyx (v0.2.2+) sind ParallelArrays. Diese nutzen die SIMD-Einheiten der CPU (SSE, AVX, NEON), um Operationen auf allen Elementen gleichzeitig auszuführen.

<code lyx>
var data := parallel Array<f64>(1024);
// Operationen wie data := data * 2.0 werden vom Compiler
// in hocheffiziente Vektor-Instruktionen übersetzt.
</code>

===== 5) Speicherverwaltung =====

Da Arrays und Maps auf dem Heap liegen, müssen sie manuell freigegeben werden, um Memory Leaks zu vermeiden:

<code lyx>
var buffer: array<uint8> := [0, 0, 0];
// ... Nutzung ...
dispose buffer; // Gibt den Heap-Speicher frei
</code>