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