Lyx — Native Power. Pure Simplicity.

Hello World

El punto de partida más simple - mínimo y eficiente.

El programa más simple en Lyx. La función main es el punto de entrada. PrintStr muestra una cadena.

hello.lyx

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

Fibonacci

Demuestra recursión y llamadas a funciones.

Un ejemplo clásico de recursión. La función fib se llama a sí misma para calcular la sucesión de Fibonacci. Observa el uso de if y bucles for.

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 con Métodos

Programación orientada a objetos con structs y métodos.

Los structs son tipos de datos definidos por el usuario. En Lyx también pueden tener métodos. El parámetro self permite el acceso a los propios campos.

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;
}

Funciones Externas

Integración con bibliotecas del sistema como libc.

Con extern se pueden incluir funciones C. Esto es útil para llamadas al sistema o usar bibliotecas como libc. ... habilita 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;
}

Arrays SIMD

Operaciones arrays paralelos para máximo rendimiento.

Los arrays paralelos usan SIMD (Single Instruction Multiple Data) para máximo rendimiento. Las operaciones se ejecutan en múltiples datos simultáneamente.

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 - Clases y Herencia

Programación orientada a objetos completa con clases, constructores y herencia.

Lyx soporta OOP completa con clases, herencia, constructores y destructores. class extends habilita herencia, new crea objetos en el 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

Arrays estáticos y dinámicos con push, sort y más.

Los arrays en Lyx pueden ser estáticos (tamaño fijo) o dinámicos (con push/pop). Usa .size para la longitud y .sort() para ordenar.

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 / Diccionarios

Almacenamiento clave-valor para búsqueda eficiente de datos.

Los maps proporcionan almacenamiento clave-valor. Accede con map[key], verifica existencia con contains(), e itera sobre claves con .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;
}