Lyx – Standard Library & Units

In Lyx wird zwischen Builtins (direkt im Compiler-Kern enthalten) und Standard-Units (in .lyx-Dateien definiert) unterschieden. Alle Funktionen folgen nun konsequent der PascalCase-Schreibweise.

1) Builtins (Global verfügbar)

Builtins benötigen keinen Import. Sie werden vom Backend direkt in effiziente Syscalls oder spezialisierte Inline-Assembler-Routinen übersetzt.

I/O & System (io.lyx)

Funktion	Signatur	Beschreibung
Exit	`(code: int64): void`	Beendet das Programm mit dem angegebenen Statuscode.
PrintStr	`(s: pchar): void`	Gibt einen nullterminierten String (C-Style) auf STDOUT aus.
PrintInt	`(x: int64): void`	Wandelt eine Ganzzahl in ASCII um und gibt sie aus.
PrintFloat	`(x: f64): void`	Gibt eine Fließkommazahl (f64) aus.

Mathematik & Zufall (math.lyx)

Funktion	Signatur	Beschreibung
Abs	`(x: int64): int64`	Liefert den absoluten Wert (Betrag) einer Ganzzahl.
Sqrt	`(x: f64): f64`	Berechnet die Quadratwurzel (nutzt native FPU/SSE Instruktion).
Random	`(): int64`	Liefert eine Pseudo-Zufallszahl ($0$ bis $2	{31}-1$).
RandomSeed	`(seed: int64): void`	Initialisiert den Zufallsgenerator (LCG) mit einem Startwert.

2) Standard Units (Erfordert Import)

Unit: std.Math

Import: `import std.Math;`

Min64 / Max64: Vergleich von zwei Ganzzahlen; liefert den kleineren bzw. größeren Wert.
Pow: Potenzberechnung ($base^{exp}$) für Fließkommazahlen.
IsEven: Hilfsfunktion, die `true` zurückgibt, wenn eine Zahl ohne Rest durch 2 teilbar ist.

Unit: std.String

Import: `import std.String;`

StrLen: Berechnet die Anzahl der Zeichen vor dem Null-Terminator (`\0`).
StrComp: Lexikografischer Vergleich zweier Strings (0 bei Gleichheit).
IntToStr: Konvertiert einen Integer in einen temporären `pchar` zur Textmanipulation.

3) Design-Richtlinie: Benennung (PascalCase)

Um die Konsistenz innerhalb des Ökosystems zu wahren, nutzt Lyx ab v0.1.7 folgende Konventionen:

Element	Stil	Beispiel
Funktionen / Methoden	PascalCase	`PrintStr`, `Create`, `Factorial`
Typen / Klassen	PascalCase	`TPlayer`, `Int64`, `Node`
Variablen / Parameter	camelCase	`counter`, `newName`, `resultValue`
Konstanten	UPPER_CASE	`MAX_LIMIT`, `PI`, `BUFFER_SIZE`
Keywords	lowercase	`fn`, `var`, `class`, `if`, `let`

4) Code-Beispiel: PascalCase in Aktion

Dieses Beispiel zeigt die Integration von Builtins und Unit-Funktionen unter Einhaltung der Benennungsrichtlinien:

unit MyApp;
 
import std.Math;
 
fn Main(): int64 {
    let input: int64 := -42;
    var result: int64 := Abs(input); // Nutzung eines Builtins
 
    // Nutzung einer Funktion aus std.Math
    if (IsEven(result)) {
        PrintStr("Die Zahl ");
        PrintInt(result);
        PrintStr(" ist gerade.");
    }
 
    return 0;
}