Lyx Beispiele — Code Samples

1. Hello World

Das einfachste mögliche Lyx-Programm.

HELLO.LYX

fn main(): int64 {
    PrintStr("Hello Lyx\n");
    return 0;
}

2. Variablen & Speicherklassen

Vier Speicherklassen steuern Veränderbarkeit und Lebensdauer: var, let, co, con.

VARIABLES.LYX

fn main(): int64 {
    // var - veränderbar
    var x: int64 := 10;
    x := x + 1;  // erlaubt

    // let - unveränderbar nach Initialisierung
    let y: int64 := 20;
    // y := 0;  // FEHLER: let ist unveränderbar

    // co - Laufzeit-Konstante (readonly)
    co z: int64 := x + y;

    // con - Compilezeit-Konstante (kein Speicher)
    con LIMIT: int64 := 100;

    PrintInt(x);  // 11
    PrintStr("\n");
    return 0;
}

3. Arrays

Stack-allokierte Arrays mit Literalen, Indizierung und Zuweisung.

ARRAYS.LYX

fn main(): int64 {
    // Array-Literal
    var arr: array := [10, 20, 30];

    // Element lesen
    var first: int64 := arr[0];  // 10

    // Element zuweisen
    arr[0] := 100;

    // Dynamischer Index
    var i: int64 := 1;
    var second: int64 := arr[i];  // 20

    PrintInt(arr[0]);  // 100
    PrintStr("\n");
    return 0;
}

4. Structs

Benutzerdefinierte Typen mit Struct-Literalen und Feldzugriff.

STRUCTS.LYX

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

fn main(): int64 {
    // Struct-Literal mit Feldinitialisierung
    var p: Point := Point { x: 10, y: 20 };

    // Feldzugriff
    PrintInt(p.x);        // 10
    PrintStr("\n");

    // Feldzuweisung
    p.x := 42;
    PrintInt(p.x);        // 42
    PrintStr("\n");

    return 0;
}

5. Struct-Methoden

Structs können Methoden mit self und statische Methoden haben.

METHODS.LYX

type Counter = struct {
    count: int64;
    
    // Instanz-Methode mit self
    fn increment(): int64 {
        self.count := self.count + 1;
        return self.count;
    }
    
    // Statische Methode - kein self, aufrufbar als Counter.zero()
    static fn zero(): Self {
        return Counter { count: 0 };
    }
};

fn main(): int64 {
    var c: Counter := Counter { count: 10 };
    c.increment();
    PrintInt(c.count);  // 11
    PrintStr("\n");
    return 0;
}

6. OOP — Klassen

Volle OOP mit Vererbung, Konstruktoren und Destruktoren.

OOP.LYX

// Basisklasse
type Animal = class {
    name: pchar;
    
    fn speak() {
        PrintStr("Irgendein Laut\n");
    }
};

// Abgeleitete Klasse mit Vererbung
type Dog = class extends Animal {
    breed: pchar;
    
    // Konstruktor
    fn Create(n: pchar, b: pchar) {
        self.name := n;
        self.breed := b;
    }
    
    // Methode überschreiben
    fn speak() {
        PrintStr("Wuff!\n");
    }
    
    // Destruktor
    fn Destroy() {
        PrintStr("Hund zerstört\n");
    }
};

fn main(): int64 {
    // Heap-Allokation mit Konstruktor
    var d: Dog := new Dog("Bello", "Labrador");
    d.speak();           // "Wuff!"
    
    dispose d;          // ruft Destroy() auf und gibt Speicher frei
    return 0;
}

7. Pipe-Operator

Verkette Funktionen mit lesbarem Links-nach-Rechts-Datenfluss durch |>.

PIPE.LYX

fn double(x: int64): int64 { return x * 2; }
fn addOne(x: int64): int64 { return x + 1; }

fn main(): int64 {
    var x: int64 := 5;
    
    // Pipe: lesbar von links nach rechts
    var result: int64 := x |> double() |> addOne();
    
    // Entspricht: addOne(double(x)) = 11
    PrintInt(result);  // 11
    PrintStr("\n");
    return 0;
}

8. Externe Funktionen

Integriere C-Bibliotheken mit extern fn und Varargs.

EXTERN.LYX

// Externe Funktionen deklarieren
extern fn malloc(size: int64): pchar;
extern fn free(ptr: pchar): void;
extern fn printf(format: pchar, ...): int64;

fn main(): int64 {
    // Speicher allokieren
    let ptr: pchar := malloc(64);
    
    // printf mit Varargs
    printf("Hallo %s, Zahl: %d\n", "Welt", 42);
    
    // Speicher freigeben
    free(ptr);
    
    return 0;
}

9. Kontrollfluss

if/else, while-Schleifen und switch/case-Anweisungen.

CONTROL.LYX

fn klassifiziere(n: int64): int64 {
    if (n > 0) {
        PrintStr("positiv\n");
    } else {
        if (n < 0) {
            PrintStr("negativ\n");
        } else {
            PrintStr("Null\n");
        }
    }
    
    // switch/case
    switch (n % 3) {
        case 0: PrintStr("durch 3 teilbar\n");
        case 1: PrintStr("Rest 1\n");
        default: PrintStr("Rest 2\n");
    }
    
    return 0;
}

fn main(): int64 {
    var i: int64 := 0;
    while (i < 3) {
        klassifiziere(i);
        i := i + 1;
    }
    return 0;
}

10. Standardbibliothek

Verwende die eingebaute Standardbibliothek.

STDLIB.LYX

// Standardbibliothek-Module importieren
import std.math;
import std.string;

fn main(): int64 {
    // Mathematische Funktionen
    var x: int64 := -42;
    PrintInt(Abs64(x));      // 42
    PrintStr("\n");
    
    // String-Funktionen
    var s: pchar := "Hallo Welt";
    PrintInt(StrLength(s));  // 10
    PrintStr("\n");
    
    // Int-zu-String-Konvertierung
    var numStr: pchar := IntToStr(12345);
    PrintStr(numStr);
    PrintStr("\n");
    
    return 0;
}

Lyx Code Beispiele