Traditionell müssen sich Programmierer beim Thema Makroprogrammierung zwischen zwei Extremen entscheiden: einem mächtigen Makrosystem oder einer leicht lesbaren Syntax. Die neue Sprache Rhombus, am 22. Juni 2026 in Version 1.0 erschienen, will beides gleichermaßen: einen einsteigerfreundlichen Blick auf einen alten Makro-Syntax-Streit und eine moderne Antwort darauf.

Rhombus ist stabil und basiert auf der ausgereiften Racket-Plattform, ist als Sprache aber noch jung und hat ein kleines Ökosystem. Also eher etwas zum Erkunden als eine naheliegende Wahl für das nächste Produktionsprojekt.

Hinter Rhombus steht das Team von Racket, einer etablierten Sprache aus der Lisp-Familie, seit Jahrzehnten in Forschung und Lehre verbreitet und für ihr besonders mächtiges Makrosystem bekannt. Das Team hat Rhombus erstmals 2023 auf der angesehenen OOPSLA-Konferenz für Programmiersprachen vorgestellt.

Kurz gefasst ist Rhombus eine universelle, dynamische Sprache mit funktionalem Kern. Daten sind standardmäßig unveränderlich, Funktionen und Ausdrücke stehen im Mittelpunkt und Pattern Matching (das Verzweigen anhand der Struktur von Daten) zieht sich durch die ganze Sprache. Dynamisch heißt dabei, dass Typen grundsätzlich zur Laufzeit geprüft werden, wie in Python oder Ruby. Zusätzlich bringt Rhombus ein vollwertiges Klassensystem für objektorientiertes Arbeiten und optionale, geprüfte Typangaben mit. Ob Entwicklerinnen und Entwickler funktional, objektorientiert oder gemischt arbeiten wollen, bleibt ihnen überlassen.

Konzeptionell ruht Rhombus auf drei technischen Schichten.

1. Shrubbery Notation: die Oberflächensyntax, also das, was man tippt, ist einrückungs- und whitespace-sensitiv, ähnlich wie bei Python. Ein Doppelpunkt : öffnet einen Block, ein senkrechter Strich | markiert Alternativen, und die Einrückung gruppiert zusammengehörigen Code. Diese Schicht ist bewusst generisch und wiederverwendbar gehalten.
2. Enforestation: eine Variante des sogenannten Pratt-Parsings (ein Verfahren, das Operator-Vorrang auflöst, also etwa weiß, dass Punkt- vor Strichrechnung kommt). Der Clou: Dieses Parsing läuft während der Makro-Expansion (also während die Makros den Code umschreiben). Dadurch können selbst definierte Infix-Operatoren echte Vorrangregeln haben und trotzdem ins saubere Makrosystem eingreifen.
3. Binding Spaces (mehrere Namensräume): Derselbe Bezeichner kann je nach Kontext etwas anderes bedeuten, etwa einen Wert, ein Bindemuster, eine Annotation (Typangabe) oder einen Operator.

Die Besonderheit: Vieles, was in anderen Sprachen fest in den Compiler eingebaut ist, ist in Rhombus eine Bibliothek: Pattern Matching, Klassen, typ-artige Annotationen und neue Kontrollstrukturen. Dieses Konzept ist dann für die einfach zu handhabende Markoprogrammierung entscheidend.

Technisch steht Rhombus auf solider Grundlage: Es läuft eben auf der Racket-Plattform, kompiliert über Chez Scheme (eine besonders schnelle Scheme-Implementierung) zu nativem Maschinencode und nutzt die etablierten Racket-Werkzeuge. Dabei ist es quelloffen und kostenlos, wahlweise unter der MIT- oder der Apache-2.0-Lizenz. Dateien tragen die Endung .rhm und beginnen mit der Zeile #lang rhombus (analog zu #lang racket).

Rhombus verhält sich also zu Racket wie Kotlin zu Java oder Elixir zu Erlang. Eine modernere Sprache auf bewährter Laufzeitumgebung.

Ein Rundgang durch den Code

Wer schon einmal programmiert hat, erkennt das meiste sofort wieder. So sieht zum Beispiel Hallo-Welt in Rhombus aus:

#lang rhombus

println("Hallo, Bob!")

Die erste Zeile #lang rhombus legt fest, in welcher Sprache die Datei geschrieben ist, danach folgt direkt der Code. Auch eine kleine Funktion bleibt übersichtlich:

#lang rhombus

fun gruesse(wen):
  "Hallo, " +& wen +& "!"

println(gruesse("Bob"))

Eine Funktion beginnt mit fun, der Doppelpunkt öffnet ihren Rumpf, die Einrückung füllt ihn (+& verbindet dabei zwei Texte). Heraus kommt „Hallo, Bob!“. Alles wirkt wie eine ganz gewöhnliche, moderne Sprache, ungefähr im Stil von Python oder Swift.

Werte definiert man mit def. Beim Rechnen lohnt ein genauer Blick: +& verbindet Text, + rechnet mit Zahlen.

#lang rhombus

def name = "Welt"
def jahr = 2026

println("Hallo, " +& name +& "!")
println(jahr + 1)

Ausgabe (als Kommentar):

// Hallo, Welt!

// 2027

Eine Funktion, wie oben im Beispiel gruesse, gibt automatisch ihren letzten Ausdruck zurück, ein return ist nicht nötig. Neu ist hier die ::-Schreibweise: Sie hängt an einen Parameter eine geprüfte Annotation, also eine Art Typangabe. a :: Int bedeutet, dass a eine ganze Zahl sein muss, und :: Int hinter der Parameterliste sagt dasselbe über den Rückgabewert. Passend zum dynamischen Charakter prüft Rhombus solche Annotationen zur Laufzeit; ein statisches Typsystem ist es also nicht.

#lang rhombus

fun addiere(a :: Int, b :: Int) :: Int:
  a + b

println(addiere(20, 22))

Ausgabe: // 42

Listen schreibt man in eckigen Klammern. Die for-Form kann zweierlei: eine neue Liste aufbauen (eine Comprehension) oder mit einem Akkumulator einen Wert aufsummieren. Ein Akkumulator ist dabei eine Sammelvariable, die in jedem Durchlauf einen neuen Wert erhält und so das Zwischenergebnis über die Durchläufe hinweg fortschreibt:

#lang rhombus

def zahlen = [1, 2, 3, 4, 5]

def quadrate = for List (z: zahlen):
  z * z

println(quadrate)

def summe = for values(akku = 0) (z: zahlen):
  akku + z

println(summe)

Ausgabe:

// [1, 4, 9, 16, 25]

// 15

Apropos Zahlen: Rhombus rechnet exakt. (3 + 4) / 2 ergibt nicht die Gleitkommazahl 3.5, sondern denselben Wert als exakten Bruch 7/2.

Pattern Matching, also das Verzweigen anhand der Struktur von Daten, durchzieht die ganze Sprache. Mit match prüft man der Reihe nach mehrere Muster, jeweils hinter einem |. Das erste passende Muster gewinnt. Beachten Sie das dritte Muster [x, y]: Es trifft nur auf Listen mit genau zwei Elementen zu und zerlegt sie gleich in x und y.

#lang rhombus

fun beschreibe(ding):
  match ding
  | 0: "die Null"
  | n :: Int: "die Zahl " +& n
  | [x, y]: "ein Paar: " +& x +& " und " +& y
  | other: "etwas anderes"

println(beschreibe(0))
println(beschreibe(42))
println(beschreibe([3, 4]))
println(beschreibe("hallo"))

Ausgabe:

// die Null

// die Zahl 42

// ein Paar: 3 und 4

// etwas anderes

Schön zu sehen: Die Muster mischen konkrete Werte (0), Annotationen (n :: Int) und Strukturen ([x, y]) in einer einheitlichen Schreibweise.

Pattern Matching in der IDE von DrRacket: Die Funktion beschreibe prüft die Muster der Reihe nach, wobei das erste passende gewinnt.

Auch ein einheitliches Klassensystem gehört dazu. Eine Klasse definiert man kurz und bündig, und dasselbe Muster, mit dem man Objekte erzeugt, lässt sich auch zum Zerlegen verwenden:

#lang rhombus

class Rechteck(breite, hoehe)

fun flaeche(r :: Rechteck):
  r.breite * r.hoehe

def r = Rechteck(10, 5)
println(r)
println(flaeche(r))

def Rechteck(b, h) = r
println("Breite: " +& b +& ", Hoehe: " +& h)

Ausgabe:

// Rechteck(10, 5)

// 50

// Breite: 10, Hoehe: 5

Die vorletzte Zeile ist bemerkenswert: def Rechteck(b, h) = r benutzt den Klassennamen nicht zum Erzeugen, sondern zum Auseinandernehmen eines Rechtecks. Genau dafür sorgen die erwähnten Binding Spaces, in denen Rechteck je nach Position etwas anderes bedeutet.

Ein weiteres Element ist die Ellipse ..., mit der sich Wiederholungen kompakt ausdrücken lassen. Das Muster [x, ...] bindet alle Elemente einer Liste auf einmal, und beim Aufbauen verteilt sich die Rechnung elementweise:

#lang rhombus

def [x, ...] = [1, 2, 3]
def [y, ...] = [10, 20, 30]

println([x + y, ...])

Ausgabe: [11, 22, 33]

Über diese Beispiele hinaus bietet Rhombus generische, unveränderliche funktionale Datenstrukturen mit guter Laufzeitkomplexität (etwa Anhängen in O(log n), also auch bei vielen Elementen schnell) und hierarchische Namensräume. Mitgeliefert sind laut Homepage Bibliotheken für HTML, JSON, XML, HTTP, Zeichnen, GUIs, Parsing und FFI-Bindings (also Anbindungen an fremde, meist C-Bibliotheken).

Bis hierhin sieht Rhombus aus wie eine moderne, aufgeräumte Sprache. Der eigentliche Clou kommt mit den Möglichkeiten der Makroprogrammierung.