Lyx – Syntax-Referenz

Diese Seite ist die vollständige Syntax-Referenz für Lyx. Sie beschreibt alle lexikalischen Regeln, Operatoren, Kontrollstrukturen und Deklarationsformen. Für konzeptuelle Erläuterungen und Code-Beispiele zu einzelnen Themen existieren eigene Unterseiten (verlinkt am Ende jedes Abschnitts).

// Einzeiliger Kommentar – bis zum Zeilenende

/* Mehrzeiliger Kommentar
   Nicht verschachtelbar: /* kein weiterer /* */ hier */

Bezeichner folgen dem Muster [A-Za-z_][A-Za-z0-9_]*. Lyx ist case-sensitive: MyVar, myVar und MYVAR sind drei verschiedene Bezeichner.

Reservierte Wörter, die nicht als Identifier verwendet werden dürfen:

and        as         break      case       class      co
con        continue   default    dispose    do         downto
else       enum       extends    false      fn         for
if         impl       import     is         let        limit
match      mod        new        nil        not        or
override   pub        repeat     return     self       struct
super      to         trait      true       type       unit
unsafe     until      var        virtual    when       while

Integer-Suffixe:

Jede Variable in Lyx trägt eine explizite Speicherklasse. Die Klasse bestimmt Mutabilität und Lebenszeit.

var counter: int64 := 0;           // Typ explizit, Wert zugewiesen
var name := "Lyx";                 // Typ inferiert: pchar
let max_val: int64 := ReadConfig(); // Einmalige Zuweisung
co PI: f64 := 3.14159265358979;    // Stack-Konstante
con MAX_BUFFER := 4096;            // Compile-Zeit-Konstante (int64 inferiert)

• Der Zuweisungsoperator ist immer :=.
• Typangabe ist optional wenn der Typ aus dem Initialisierer eindeutig inferierbar ist.
• pub vor der Speicherklasse macht die Variable aus anderen Units sichtbar: pub var x: int64 := 0;

var p:  ^int64   := ^x;      // Pointer auf int64 (Address-of: ^x)
var pp: ^(^int64) := ^p;     // Pointer auf Pointer auf int64
var v:  ^uint8   := nil;     // Null-Pointer

p^  := 42;                   // Dereferenz (Schreiben)
PrintInt(p^);                 // Dereferenz (Lesen)

Alle Pointer sind intern 64-Bit-Integer. Der Cast ptr as int64 und addr as ^T ist explizit möglich.

Das ?-Suffix markiert einen Typ als nullable (kann nil sein):

var name: pchar?  := GetOptionalName();    // darf nil sein
var node: BSTNode? := FindNode(key);

type Altitude = int64 range -1000..60000;
type Speed    = int64 range 0..300;

Compile-Zeit: Literale außerhalb des Bereichs → Fehler. Laufzeit: Nicht-konstante Zuweisung → panic.

if (Bedingung) {
    // ...
} else if (andere_Bedingung) {
    // ...
} else {
    // ...
}

if ist kein Ausdruck – es gibt keinen ternären Operator ?:. Bedingte Werte werden über match oder Hilfsfunktionen ausgedrückt.

while (Bedingung) {
    // ...
}

// Bounded – garantierte Terminierung
while (Bedingung) limit(Konstante) {
    // ...
}

// Aufwärts (inklusive Grenzen)
for i := Startwert to Endwert do {
    // i läuft von Startwert bis einschließlich Endwert
}

// Abwärts
for i := Endwert downto Startwert do {
    // i läuft von Endwert bis einschließlich Startwert
}

Die Laufvariable wird automatisch inkrementiert / dekrementiert. Ihr Typ wird vom Compiler inferiert. for-Schleifen sind immer bounded – kein limit erforderlich.

repeat {
    // Körper wird mindestens einmal ausgeführt
} until (Abbruchbedingung);

// Mit Bounded-Limit
repeat {
    // ...
} until (Bedingung) limit(Konstante);

while (true) {
    if (DoneCondition()) { break; }    // verlässt die innerste Schleife
    if (SkipCondition()) { continue; } // springt zum nächsten Durchlauf
}

break und continue wirken immer auf die innerste umgebende Schleife.

match (Ausdruck) {
    case Wert       => Anweisung;
    case A | B      => Anweisung;      // OR-Muster
    case lo..hi     => Anweisung;      // Bereichsmuster
    case X when (Guard) => Anweisung;  // mit Guard-Bedingung
    default         => Anweisung;
}

match kann als Ausdruck verwendet werden (Ergebnis einer Case-Arm-Anweisung). Alle Fälle müssen abgedeckt sein (Exhaustivität). Details: Pattern Matching.

fn FunktionsName(param1: Typ1, param2: Typ2): RückgabeTyp {
    // Körper
    return Wert;
}

• Kein Rückgabewert: Rückgabetyp und return werden weggelassen (implizit void).
• Mehrere Rückgabewerte: Tupel-Syntax (Typ1, Typ2).
• Öffentliche Sichtbarkeit: pub voranstellen.

// Einfache Funktion
fn Add(a: int64, b: int64): int64 {
    return a + b;
}

// Keine Rückgabe (void)
fn Log(msg: pchar) {
    PrintStr(msg);
}

// Tupel-Rückgabe (mehrere Werte)
fn Divide(a: int64, b: int64): (int64, bool) {
    if (b = 0) { return (0, false); }
    return (a / b, true);
}

// Öffentlich
pub fn GetVersion(): pchar {
    return "1.0.0";
}

var result := Add(3, 4);

var (quotient, ok) := Divide(10, 3);
if (ok) { PrintInt(quotient); }

// Pipe-Operator: Wert als erstes Argument
var v := -3.14 |> Abs() |> Round();

→ Funktionen (vertieft) — Tupel-Rückgabe, anonyme Funktionen, Higher-Order Functions, Pipe-Operator

Jede Lyx-Quelldatei beginnt mit einer unit-Deklaration. Sie definiert den Namensraum der Datei.

unit my_module;

import std.io;
import std.math;
import my_project.utils;

• unit-Name und Dateiname müssen übereinstimmen (my_module.lyx → unit my_module;).
• import macht alle pub-Symbole der Ziel-Unit sichtbar.
• Standard-Bibliothek: std.io, std.math, std.string, std.alloc, std.result, std.error, …

Stack-allozierte Wertetypen. Zuweisung kopiert den gesamten Wert.

type Vec2 = struct {
    x: f64;
    y: f64;

    fn Length(): f64 {
        return Sqrt(self.x * self.x + self.y * self.y);
    }

    fn Scale(factor: f64) {
        self.x := self.x * factor;
        self.y := self.y * factor;
    }
};

Heap-allozierte Referenztypen. new erzeugt, dispose gibt frei.

type Animal = class {
    name: pchar;

    fn Create(n: pchar) {
        self.name := n;
    }

    fn Destroy() {
        // Aufräum-Logik
    }

    virtual fn Speak() {
        PrintStr(self.name);
    }
};

type Dog = class extends Animal {
    override fn Speak() {
        PrintStr("Wuff!");
    }
};

var d := new Dog("Bello");
d.Speak();    // "Wuff!"
dispose d;

Schlüsselwörter für Klassen:

enum Richtung { Nord, Sued, Ost, West }

enum StatusCode {
    Ok     = 200,
    NotFound = 404,
    Error  = 500
}

// Zugriff über ::
var d := Richtung::Nord;
var s := StatusCode::Ok;

match über Enums prüft Exhaustivität: Fehlt ein Fall, erzeugt der Compiler einen Fehler.

trait Printable {
    fn Print();
    fn ToString(): pchar;   // muss implementiert werden
}

type Point = struct { x: int64; y: int64; };

impl Printable for Point {
    fn Print() {
        PrintStr(self.ToString());
    }

    fn ToString(): pchar {
        return FormatStr("(%d, %d)", self.x, self.y);
    }
}

Generics mit Trait-Schranken:

fn PrintAll<T: Printable>(items: [16]T) {
    for i := 0 to 15 do {
        items[i].Print();
    }
}

// Generische Funktion
fn Max<T: Comparable>(a: T, b: T): T {
    if (a > b) { return a; }
    return b;
}

// Generischer Struct
type Stack<T> = struct {
    data: [64]T;
    top:  int64;

    fn Push(val: T) {
        self.data[self.top] := val;
        self.top++;
    }

    fn Pop(): T {
        self.top--;
        return self.data[self.top];
    }
};

// Mehrere Schranken mit +
fn Process<T: Printable + Comparable>(val: T) {
    val.Print();
}

Attribute beginnen mit @ und stehen unmittelbar vor dem annotierten Element (Unit, Funktion, Variable).

Program    → (Unit Import* Decl*)?
Unit       → 'unit' Ident ';'
Import     → 'import' QualIdent ';'

Decl       → VarDecl | FnDecl | TypeDecl | TraitDecl | ImplDecl

VarDecl    → Modifier? StorageClass Ident (':' Type)? ':=' Expr ';'
StorageClass → 'var' | 'let' | 'co' | 'con'
Modifier   → 'pub'

FnDecl     → Attr* Modifier? 'fn' Ident GenericParams? '(' Params ')' (':' Type)? Block
Params     → (Ident ':' Type (',' Ident ':' Type)*)?

TypeDecl   → 'type' Ident GenericParams? '=' ('struct' | 'class' ('extends' Ident)?) '{' Member* '}'
EnumDecl   → 'enum' Ident '{' (Ident ('=' IntLit)? (',' Ident ('=' IntLit)?)*)? '}'
TraitDecl  → 'trait' Ident '{' FnSignature* '}'
ImplDecl   → 'impl' Ident 'for' Ident '{' FnDecl* '}'

Block      → '{' Stmt* '}'
Stmt       → VarDecl | ExprStmt | IfStmt | WhileStmt | ForStmt | RepeatStmt
           | MatchStmt | ReturnStmt | BreakStmt | ContinueStmt | UnsafeBlock

IfStmt     → 'if' '(' Expr ')' Block ('else' 'if' '(' Expr ')' Block)* ('else' Block)?
WhileStmt  → 'while' '(' Expr ')' ('limit' '(' IntLit ')')? Block
ForStmt    → 'for' Ident ':=' Expr ('to' | 'downto') Expr 'do' Block
RepeatStmt → 'repeat' Block 'until' '(' Expr ')' ('limit' '(' IntLit ')')? ';'
MatchStmt  → 'match' '(' Expr ')' '{' MatchArm* '}'
MatchArm   → ('case' Pattern ('when' '(' Expr ')')? | 'default') '=>' Stmt ';'

Expr       → ... (vollständige Präzedenz-Hierarchie; siehe Abschnitt 5)

Weiterführende Seiten:

• Datentypen – vollständige Typ-Referenz
• Erste Schritte – Einführung mit Beispielen
• Pattern Matching – match im Detail
• OOP – Klassen, Traits, Generics
• Pointer & Inlining – ^T, unsafe, @inline
• Attribute & Pragmas – vollständige @-Referenz
• FFI – @extern, @export, @packed