Lyx – Objektorientierte Programmierung (OOP)

Lyx kombiniert die Performance von Systemprogrammiersprachen mit der Ergonomie moderner OOP-Sprachen. Dabei wird strikt zwischen leichtgewichtigen Strukturen und mächtigen Klassen unterschieden.

Strukturen sind Datengruppierungen, die standardmäßig auf dem Stack liegen. Sie sind ideal für kleine Objekte (Vektoren, Punkte, Farben), bei denen keine Vererbung benötigt wird.

Zuweisung: Erfolgt durch Kopieren des Inhalts (Copy-by-Value).

Methoden: Können Methoden besitzen, unterstützen aber keine Polymorphie.

type TPoint = struct {
x, y: int64;
 
fn Move(dx: int64, dy: int64) {
    self.x := self.x + dx;
    self.y := self.y + dy;
}
};

Klassen sind komplexe Objekte, die auf dem Heap verwaltet werden. Sie unterstützen Vererbung, virtuelle Methoden und das Erstellen von Instanzen via new.

Alle Klassen stammen standardmäßig von TObject ab, sofern nicht anders angegeben.

type Entity = class {
var id: int64;
var name: pchar;
 
// Konstruktor (wird via new aufgerufen)
fn Create(newId: int64, newName: pchar) {
    self.id := newId;
    self.name := newName;
}
 
fn Describe() {
    PrintStr("Entity: ");
    PrintStr(self.name);
}
};
 
// Vererbung
type Player = class extends Entity {
var health: int32;
 
fn Describe() {
    super.Describe(); // Aufruf der Basisklasse
    PrintStr(" (HP: ");
    PrintInt(self.health as int64);
    PrintStr(")");
}
};

Da Lyx keinen Garbage Collector hat, muss die Lebensdauer von Klassen-Instanzen manuell gesteuert werden.

Lyx nutzt einfache Keywords, um den Zugriff auf Member zu steuern:

pub: Macht ein Feld oder eine Methode von außerhalb der Unit zugänglich.

(Standard): Ohne pub sind Member nur innerhalb der eigenen Unit sichtbar (Internal).

type Database = class {
pub var ConnectionString: pchar; // Öffentlich
var InternalSocket: int64;      // Privat (nur in dieser Unit)
};

In Lyx kannst du zur Laufzeit prüfen, ob ein Objekt von einem bestimmten Typ ist, und es sicher umwandeln.

is: Prüft die Typ-Kompatibilität.

as: Führt einen Cast durch (bei Klassen wird die Referenz umgedeutet).

fn Process(e: Entity) {
if (e is Player) {
let p := e as Player;
p.health := 100;
}
}