Lyx — Native Power. Pure Simplicity.

Hello World

Der klassische Startpunkt - minimal und effizient.

Das einfachste Programm in Lyx. Die main-Funktion ist der Einstiegspunkt. PrintStr gibt einen String aus.

hello.lyx

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

Fibonacci

Demonstriert Rekursion und Funktionsaufrufe.

Ein klassisches Beispiel für Rekursion. Die Funktion fib ruft sich selbst auf, um die Fibonacci-Folge zu berechnen. Beachte die Verwendung von if und for-Schleifen.

fibonacci.lyx

fn fib(n: int64): int64 {
    if n <= 1 {
        return n;
    }
    return fib(n - 1) + fib(n - 2);
}

fn main(): int64 {
    for i := 0; i < 10; i++ {
        PrintInt(fib(i));
        PrintStr(" ");
    }
    PrintStr("\n");
    return 0;
}

Struct mit Methoden

Objektorientierte Programmierung mit Structs und Methoden.

Structs sind benutzerdefinierte Datentypen. In Lyx können sie auch Methoden haben. Der self-Parameter ermöglicht den Zugriff auf die eigenen Felder.

struct.lyx

type Point = struct {
    x: int64;
    y: int64;
    
    fn Create(newX, newY: int64): Point {
        var p: Point;
        p.x := newX;
        p.y := newY;
        return p;
    }
    
    fn distance(self: Point): int64 {
        return self.x * self.x + self.y * self.y;
    }
}

fn main(): int64 {
    var p := Point::Create(3, 4);
    PrintInt(p.distance());  // 25
    return 0;
}

Externe Funktionen

Integration mit Systembibliotheken wie libc.

Mit extern können C-Funktionen eingebunden werden. Dies ist nützlich für Systemaufrufe oder die Verwendung von Bibliotheken wie libc. Das ... ermöglicht Varargs.

extern.lyx

extern fn printf(fmt: pchar, ...): int64;
extern fn exit(code: int64): void;

fn main(argc: int64, argv: pchar): int64 {
    if argc < 2 {
        printf("Usage: %s <name>\n", argv[0]);
        exit(1);
    }
    printf("Hello, %s!\n", argv[1]);
    return 0;
}

SIMD Arrays

Parallele Array-Operationen für maximale Leistung.

Parallele Arrays nutzen SIMD (Single Instruction Multiple Data) für maximale Performance. Operationen werden auf mehreren Daten gleichzeitig ausgeführt.

simd.lyx

import std.math;

fn main(): int64 {
    // Create parallel array of 1000 f64 elements
    var arr: parallel Array<f64>;
    arr.size := 1000;
    
    // Fill with values
    for i := 0; i < 1000; i++ {
        arr[i] := i as f64;
    }
    
    // SIMD operations - processes multiple elements at once
    arr := arr * 2.0;  // Multiply all by 2
    arr := arr + 1.0;  // Add 1 to all
    
    PrintInt(arr[0] as int64);  // 1
    return 0;
}

OOP - Klassen und Vererbung

Vollständige objektorientierte Programmierung mit Klassen, Konstruktoren und Vererbung.

Lyx unterstützt vollständige OOP mit Klassen, Vererbung, Konstruktoren und Destruktoren. class extends ermöglicht Vererbung, new erzeugt Objekte auf dem Heap.

class.lyx

// Basisklasse
type Animal = class {
    name: pchar;
    
    fn Create(n: pchar) {
        self.name := n;
    }
    
    fn speak(self: Animal) {
        PrintStr("Some sound\n");
    }
};

// Abgeleitete Klasse mit Vererbung
type Dog = class extends Animal {
    breed: pchar;
    
    fn Create(n, b: pchar) {
        super.Create(n);
        self.breed := b;
    }
    
    fn speak(self: Dog) {
        PrintStr("Woof! Woof!\n");
    }
};

fn main(): int64 {
    // Objekte mit new erstellen (Heap-Allokation)
    var dog := new Dog("Buddy", "Labrador");
    
    dog.speak();      // Output: Woof! Woof!
    PrintStr(dog.name);
    PrintStr(" is a ");
    PrintStr(dog.breed);
    PrintStr("\n");
    
    // Speicher freigeben
    dispose dog;
    
    return 0;
}

Arrays

Statische und dynamische Arrays mit push, sort und mehr.

Arrays in Lyx können statisch (feste Größe) oder dynamisch (mit push/pop) sein. Nutze .size für die Länge und .sort() zum Sortieren.

arrays.lyx

fn main(): int64 {
    // Statisches Array mit fester Größe
    var nums: Array<int64>;
    nums.size := 5;
    
    // Array befüllen
    for i := 0; i < 5; i++ {
        nums[i] := i * 10;
    }
    
    // Array durchlaufen
    for i := 0; i < nums.size; i++ {
        PrintInt(nums[i]);
        PrintStr(" ");
    }
    PrintStr("\n");  // 0 10 20 30 40
    
    // Dynamisches Array
    var dynArr: Array<pchar>;
    dynArr.push("apple");
    dynArr.push("banana");
    dynArr.push("cherry");
    
    for i := 0; i < dynArr.size; i++ {
        PrintStr(dynArr[i]);
        PrintStr(" ");
    }
    PrintStr("\n");  // apple banana cherry
    
    // Array sortieren
    var sorted: Array<int64>;
    sorted.push(3);
    sorted.push(1);
    sorted.push(4);
    sorted.push(1);
    sorted.push(5);
    sorted.sort();
    
    for i := 0; i < sorted.size; i++ {
        PrintInt(sorted[i]);
    }
    PrintStr("\n");  // 11345
    
    return 0;
}

Maps / Dictionaries

Key-Value-Stores für effiziente Datensuche.

Maps bieten Key-Value-Speicherung. Zugriff mit map[key], Existenzprüfung mit contains(), Iteration über Keys mit .keys().

maps.lyx

fn main(): int64 {
    // Map (Key-Value Store)
    var ages: Map<pchar, int64>;
    
    // Schlüssel-Wert-Paare hinzufügen
    ages["Alice"] := 30;
    ages["Bob"] := 25;
    ages["Charlie"] := 35;
    
    // Werte abrufen
    PrintStr("Alice ist ");
    PrintInt(ages["Alice"]);
    PrintStr(" Jahre alt.\n");
    
    // Prüfen ob Schlüssel existiert
    if ages.contains("Bob") {
        PrintStr("Bob gefunden!\n");
    }
    
    // Map iterieren
    var keys := ages.keys();
    for i := 0; i < keys.size; i++ {
        PrintStr(keys[i]);
        PrintStr(": ");
        PrintInt(ages[keys[i]]);
        PrintStr("\n");
    }
    
    // Wert entfernen
    ages.remove("Bob");
    
    // Map mit verschiedenen Typen
    var mixed: Map<pchar, void>;
    mixed["name"] := "Lyx";
    mixed["version"] := 1;
    mixed["active"] := true;
    
    return 0;
}