====== Lyx – Arrays, Maps & Datensammlungen ======

Lyx unterscheidet vier Container-Formen. Die Wahl zwischen ihnen ist keine Stilfrage, sondern eine Sicherheits- und Architekturentscheidung: Stack-Arrays sind deterministisch und DO-178C-tauglich, Heap-Arrays sind flexibel aber nicht echtzeitfähig, SIMD-Arrays für numerische Hochleistungsberechnungen, Maps für Schlüssel-Wert-Zugriff.

→ [[lyx_-_programmiersprache:datentypen|Datentypen]] · [[lyx_-_programmiersprache:memory-management|Memory Management]] · [[lyx_-_programmiersprache:do-178c|DO-178C]]

----

===== 1. Statische Arrays — [N]T =====

Statische Arrays liegen auf dem **Stack**. Größe und Typ stehen zur Compile-Zeit fest und sind unveränderlich. Das ist die bevorzugte Form für sicherheitskritischen und echtzeitfähigen Code.

==== Syntax ====

<code lyx>
// [Größe]Typ — Typ-zuerst-Notation (wie Go/Zig, NICHT wie C)
var buffer:  [256]uint8 := [];              // 256 Bytes, nullinitialisiert
var coords:  [3]f64     := [0.0, 0.0, 0.0];
var ids:     [16]int64  := [];

// let — unveränderliche Bindung (Werte im Array selbst bleiben änderbar)
let defaults: [4]int64 := [0, 1, 2, 3];
</code>

> **Wichtig:** Die Syntax ist ''[N]T'' — Größe in eckigen Klammern **vor** dem Typ. ''T[N]'' (C-Stil) ist in Lyx kein gültiger Typ.

==== Zugriff und Zuweisung ====

<code lyx>
var coords: [3]f64 := [0.0, 0.0, 0.0];

coords[0] := 10.5;            // Schreiben
coords[1] := coords[0];       // Lesen und Schreiben
var z: f64 := coords[2];      // Lesen

// Bounds-Checking:
// — Konstanter Index außerhalb der Grenzen → Compile-Fehler
// — Variabler Index außerhalb der Grenzen  → kontrolliertes panic zur Laufzeit
</code>

==== Mehrdimensionale statische Arrays ====

<code lyx>
// 8×8-Matrix — flaches Layout im Speicher (64 × 8 Bytes = 512 Bytes)
var grid: [8][8]int64 := [];
grid[3][4] := 99;

var val: int64 := grid[3][4];   // 99
</code>

==== Safety-Eigenschaften ====

  * Keine Heap-Allokation — kein Fragmentierungsrisiko, kein GC-Druck
  * Bounds-Checking bei konstantem Index zur Compile-Zeit
  * Bounds-Checking bei variablem Index zur Laufzeit (kontrollierbarer ''panic'')
  * Maximaler Stack-Verbrauch statisch berechenbar → kompatibel mit ''@stack_limit''
  * Kein ''dispose'' nötig — Stack-Frame wird automatisch freigegeben

<code lyx>
// DO-178C DAL-A: Waypoint-Liste als statisches Array
@dal(A)
@flight_crit
@stack_limit(2048)
@wcet(100)
fn FindNearest(wps: [32]Waypoint, n: int64, pos: GeoPoint): int64 {
    var best: int64 := 0;
    var best_d: f64 := 1.0e18;
    for i := 0 to n - 1 do {
        var d: f64 := GeoDistance(pos, wps[i].pos);
        if (d < best_d) { best_d := d; best := i; }
    }
    return best;
}
</code>

----

===== 2. Dynamische Arrays — array<T> =====

Dynamische Arrays liegen auf dem **Heap** und wachsen automatisch. Intern speichern sie drei Werte (Fat-Pointer): Speicheradresse, aktuelle Länge (''len'') und reservierte Kapazität (''cap'').

==== Syntax und Operationen ====

<code lyx>
import std.io;

var list: array<int64> := [10, 20, 30];

list.push(40);                        // Anhängen
list.push(50);

PrintInt(list.len());                 // 5
PrintInt(list.cap());                 // Reservierte Kapazität (≥ len)
PrintInt(list[0]);                    // 10

list[0] := list[0] + 1;              // Lesen und Schreiben (kein ++ Operator in Lyx)
list[2] := 999;

list.clear();                         // len := 0, Speicher bleibt reserviert
PrintInt(list.len());                 // 0

dispose list;                         // Zwingend — sonst Memory Leak
</code>

==== dispose mit mehreren return-Pfaden ====

Verlässt eine Funktion über mehrere Pfade, muss ''dispose'' **vor jedem** ''return'' stehen:

<code lyx>
fn LoadConfig(path: pchar): bool {
    var cfg: Map<pchar, int64> := {};

    if (ParseFile(path, cfg) = false) {
        dispose cfg;      // Auch im Fehlerfall freigeben
        return false;
    }

    ApplyConfig(cfg);
    dispose cfg;
    return true;
}
</code>

> Lyx hat kein automatisches RAII/Destruktor-System für Heap-Typen. Bei mehreren ''return''-Pfaden statische Arrays ''[N]T'' bevorzugen — kein ''dispose'', kein Leak-Risiko.

==== Wann array<T> sinnvoll ist ====

  * Anzahl der Elemente zur Compile-Zeit unbekannt
  * Server- und Tool-Code, bei dem Flexibilität wichtiger ist als deterministisches Timing
  * **Nicht** in DAL-A/B-Regelschleifen — Heap-Allokation hat nicht-deterministische Latenz

> In Funktionen mit ''@flight_crit'' warnt der Compiler bei Heap-Allokation. Ausschließlich ''[N]T'' verwenden.

----

===== 3. Parallele Arrays — parallel Array<T> =====

Parallele Arrays sind Heap-Arrays mit garantiertem **SIMD-Alignment** (16 Byte für SSE/NEON, 32 Byte für AVX). Batch-Operationen auf diesen Arrays übersetzt der Compiler direkt in Vektor-Instruktionen.

<code lyx>
var data: parallel Array<f64> := parallel Array<f64>(1024);

data[0] := 1.0;
data[1] := 2.0;

// Batch-Skalierung — compiler übersetzt in SSE/AVX/NEON
// data := data * 2.0;

dispose data;
</code>

==== Einsatzgebiete ====

  * Signalverarbeitung (FFT, Filter, Fensterfunktionen)
  * Lineare Algebra (Matrix-Vektor-Produkt)
  * Machine-Learning-Inferenz (Dot-Produkte, Aktivierungen)
  * Physik-Simulationen (Partikelsysteme, Kraftfelder)

  * Nur für primitive Typen: ''f32'', ''f64'', ''int32'', ''int64''
  * Kein Einsatz in DAL-A/B-Regelschleifen — SIMD-Timing nicht vorhersehbar genug

----

===== 4. Maps — Map<K, V> =====

Maps erlauben den Zugriff über einen Schlüssel. Lyx bietet native Literal-Syntax seit v0.5.0.

==== Erstellen, Lesen, Schreiben ====

<code lyx>
import std.io;

var scores: Map<pchar, int64> := {"Alpha": 100, "Bravo": 250, "Charlie": 175};

// Lesen
var s: int64 := scores["Alpha"];    // 100

// Schreiben / Einfügen
scores["Delta"] := 300;

// Existenzprüfung mit in — immer vor Zugriff auf unbekannte Schlüssel
if ("Delta" in scores) {
    PrintInt(scores["Delta"]);      // 300
    PrintStr("\n");
}

// Löschen eines Eintrags
delete scores["Charlie"];

dispose scores;
</code>

==== Iteration ====

<code lyx>
var config: Map<pchar, int64> := {
    "timeout_ms":  5000,
    "retry_count": 3,
    "log_level":   2
};

for key, val in config do {
    PrintStr(key); PrintStr(": "); PrintInt(val); PrintStr("\n");
}
// Ausgabe (Reihenfolge implementierungsabhängig):
// timeout_ms: 5000
// retry_count: 3
// log_level: 2

dispose config;
</code>

==== Map<pchar, pchar> ====

<code lyx>
var headers: Map<pchar, pchar> := {
    "Content-Type":  "application/json",
    "Authorization": "Bearer abc123"
};

if ("Content-Type" in headers) {
    PrintStr(headers["Content-Type"]);   // application/json
    PrintStr("\n");
}

dispose headers;
</code>

==== Performance-Modell ====

  * **< 128 Einträge:** Cache-optimierte lineare Suche — O(n), aber sehr schnell durch Lokalität
  * **≥ 128 Einträge:** Hash-Verfahren — O(1) amortisiert, automatischer Wechsel

----

===== 5. Speicherverwaltung — Heap-Container =====

Alle Heap-Container (''array<T>'', ''parallel Array<T>'', ''Map<K,V>'') müssen explizit freigegeben werden:

<code lyx>
fn ProcessData(): void {
    var buf:  array<uint8>         := [];
    var data: parallel Array<f64>  := parallel Array<f64>(256);
    var meta: Map<pchar, int64>    := {};

    // ... Verarbeitung ...

    dispose buf;
    dispose data;
    dispose meta;
}
</code>

Wird ''dispose'' vergessen, entsteht ein Memory Leak — besonders in Langzeit-Systemen (Avionik, Server) kritisch.

----

===== 6. Zusammenfassung & Safety-Matrix =====

^ Typ ^ Syntax ^ Ort ^ Timing ^ DO-178C DAL-A ^ dispose ^
| Statisches Array | ''[N]T'' | Stack | Deterministisch | ✅ | Nein |
| Dynamisches Array | ''array<T>'' | Heap | Nicht-deterministisch | ✗ (nur Init) | Ja |
| Paralleles Array | ''parallel Array<T>'' | Heap (SIMD) | Nicht-deterministisch | ✗ | Ja |
| Map | ''Map<K, V>'' | Heap | Nicht-deterministisch | ✗ | Ja |

^ Eigenschaft ^ ''[N]T'' ^ ''array<T>'' ^ ''parallel Array<T>'' ^ ''Map<K,V>'' ^
| Größe zur Compile-Zeit | Ja | Nein | Nein | Nein |
| Bounds-Checking | Compile + Runtime | Runtime | Runtime | Runtime |
| @stack_limit-kompatibel | Ja | Nein | Nein | Nein |
| SIMD-Vektorisierung | Nein | Nein | Ja | Nein |
| Schlüssel-Zugriff | Nein | Nein | Nein | Ja |
| for key, val in | Nein | Nein | Nein | Ja |

----

Letzte Aktualisierung: 2026-05-22