Flux-Sprache: Neue Funktionen für Compile-Time-Execution und Typsicherheit

Die junge Programmiersprache Flux hat in ihrer jüngsten Entwicklungsphase bedeutende Fortschritte gemacht. Was einst als kompakte Low-Level-Sprache begann, entwickelt sich nun zu einem vielseitigen Werkzeug mit innovativen Funktionen. Besonders die Compile-Time-Execution und erweiterte Typensysteme heben Flux von etablierten Sprachen ab und bieten Entwicklern neue Möglichkeiten für präzisen und sicheren Code.

Echte Code-Ausführung zur Compile-Zeit mit comptime

Eine der herausragendsten Neuerungen ist die Compile-Time-Execution durch comptime. Flux führt damit echten Code bereits während der Kompilierung aus – nicht durch Makros oder Const-Expressions, sondern durch eine dedizierte virtuelle Maschine, die speziell für diesen Zweck entwickelt wurde. Der Mechanismus ist denkbar einfach: Umgeben Sie beliebigen Code mit einem comptime-Block, und er wird während der Kompilierung ausgeführt, noch bevor der generierte Runtime-Code entsteht.

#import <standard.fx>;

comptime {
  def foo() -> void {
    compiler.io.console.print("Hello from compile time!\n");
  };
  foo();
};

def main() -> int {
  return 0;
};

Bei der Kompilierung dieses Beispiels erscheint die Ausgabe Hello from compile time! direkt in den Compiler-Ausgaben – mitten im Prozess der AST-Codegenerierung. Die comptime-Blöcke können dabei sogar komplexe Logik ausführen und teilen sich untereinander denselben Scope. So lassen sich mehrstufige Compile-Time-Berechnungen realisieren, die etwa Build-Konfigurationen vorberechnen oder Code-Generierung durchführen.

Algebraische Typen und relationale Typsysteme

Flux integriert nun relationale Typsysteme, die über einfache Typenparameter hinausgehen. Mit dem neuen Schlüsselwort constraint können Entwickler benannte Einschränkungen für Typen definieren, die algebraische Beziehungen zwischen Typparametern ausdrücken. Diese Constraints werden an Template-Funktionen gebunden und stellen sicher, dass nur gültige Kombinationen von Typen instantiiert werden können.

constraint SafeArith(A, B) {
  A ~= B,  // A und B müssen kompatibel sein
  A !`< A  // A darf sich nicht selbst verengen lassen
};

def add<T: int, U: int, :{SafeArith}>(T x, U y) -> T {
  return x + y;
};

Die verfügbaren Operatoren ermöglichen präzise Kontrolle über Typrestriktionen:

• ~= – Typen müssen kompatibel sein (gleiche Pointertiefe, Bitbreite)
• !~= – Typen müssen inkompatibel sein
• !< – Keine Verengung zulassen
• !<= / !>= – Spezifische Verengungs- oder Erweiterungsverbote
• !-= – Verbot für unsigned-Arithmetik

Diese Constraints lassen sich direkt an Typparameter binden oder in Ketten kombinieren, um komplexe Typenbeziehungen auszudrücken. Das System verhindert etwa, dass bestimmte Typen ihre Adresse verlieren oder unerwünschte Typumwandlungen durchführen können – und gibt dabei präzise Fehlermeldungen aus, statt vage Template-Fehler zu werfen.

Schnittstellen für präzise Typverträge

Flux führt nun Interfaces ein, die über die bisherigen Traits hinausgehen und definieren, wie zwei Objekte miteinander kommunizieren müssen. Während Traits das Verhalten einzelner Objekte beschreiben, legen Interfaces fest, welche Methoden zwischen zwei Objekten ausgetauscht werden dürfen – und zwar statisch zur Compile-Zeit.

trait Readable {
  def read(byte*, int) -> int;
  def write(byte*, int) -> int;
  def flush() -> int;
};

trait Writable {
  def ack() -> int;
};

interface Stream(A: Readable, B: Writable) {
  A : B {
    read(byte*, int) -> int,
    write(byte*, int) -> int,
    flush() -> int
  };
  B : A {
    ack() -> int
  };
};

Ein Interface wird einem Objekt an dessen Definition zugewiesen und fungiert als verbindlicher Vertrag. Jeder Methodenaufruf zwischen den beteiligten Objekten, der nicht explizit im Interface aufgeführt ist, wird vom Compiler abgelehnt – selbst wenn die Methode öffentlich zugänglich ist. Dies eliminiert Runtime-Overhead und unnötige Boilerplate, während es gleichzeitig die Kommunikation zwischen Komponenten formalisiert.

Kein Diamant-Problem: Einfache Mehrfachvererbung

Mit der Einführung von Objekterbschaft unterstützt Flux nun auch Mehrfachvererbung. Doch statt das klassische Diamant-Problem zuzulassen, verhindert der Compiler dessen Entstehung von vornherein. Durch klare Regeln zur Auflösung von Namenskollisionen wird sichergestellt, dass Mehrfachvererbung zuverlässig und ohne unerwartete Seiteneffekte funktioniert.

object A {
  int a1, a2;
}

object B {
  int b1;
}

object C : A, B {
  int c1;
}

Die Implementierung vermeidet die typischen Fallstricke von Vererbungshierarchien und bietet Entwicklern eine sichere Grundlage für modulare Code-Strukturen.

Fazit: Flux als ernstzunehmende Alternative

Mit der Compile-Time-Execution, relationalen Typsystemen und Interfaces positioniert sich Flux als ernsthafte Alternative für Entwickler, die Wert auf Präzision, Sicherheit und Ausdrucksstärke legen. Die Sprache entfernt sich damit von ihrem ursprünglichen Low-Level-Fokus und bietet nun Features, die sonst nur in komplexen oder experimentellen Systemen zu finden sind. Besonders die statische Überprüfung von Typsicherheit und Kommunikationsverträgen könnte Flux für zukünftige Projekte attraktiv machen – vorausgesetzt, die Community findet Wege, die Sprache in der Praxis einzusetzen.