Programmiersprachen mit einem Lisp-ähnlichen Syntaxerweiterungsmechanismus [geschlossen]

Ich habe nur begrenzte Kenntnisse in Lisp (versuche in meiner Freizeit ein bisschen zu lernen), aber soweit ich Lisp-Makros verstehe, können neue Sprachkonstrukte und Syntax eingeführt werden, indem sie in Lisp selbst beschrieben werden. Dies bedeutet, dass ein neues Konstrukt als Bibliothek hinzugefügt werden kann, ohne den Lisp-Compiler / -Interpreter zu ändern.

Dieser Ansatz unterscheidet sich stark von dem anderer Programmiersprachen. Wenn ich beispielsweise Pascal mit einer neuen Art von Schleife oder einer bestimmten Redewendung erweitern wollte, müsste ich die Syntax und Semantik der Sprache erweitern und dann diese neue Funktion im Compiler implementieren.

Gibt es andere Programmiersprachen außerhalb der Lisp-Familie (außer Common Lisp, Scheme, Clojure (?), Racket (?) Usw.), die eine ähnliche Möglichkeit bieten, die Sprache innerhalb der Sprache selbst zu erweitern?

BEARBEITEN

Vermeiden Sie bitte längere Diskussionen und geben Sie Ihre Antworten genau an. Anstelle einer langen Liste von Programmiersprachen, die auf die eine oder andere Weise erweitert werden können, möchte ich aus konzeptioneller Sicht verstehen, was für Lisp-Makros als Erweiterungsmechanismus spezifisch ist und welche Nicht-Lisp-Programmiersprachen ein Konzept bieten das ist nah an ihnen.

Scala macht dies auch möglich (tatsächlich wurde es bewusst entwickelt, um die Definition neuer Sprachkonstrukte und sogar vollständiger DSLs zu unterstützen).

Abgesehen von Funktionen höherer Ordnung, Lambdas und Currying, die in funktionalen Sprachen üblich sind, gibt es hier einige spezielle Sprachmerkmale, die dies ermöglichen *:

• keine Operatoren - alles ist eine Funktion, aber Funktionsnamen können Sonderzeichen wie '+', '-' oder ':' enthalten
• Punkte und geschweifte Klammern können für Einzelparameter-Methodenaufrufe weggelassen werden, dh sie a.and(b)entsprechen a and bin Infixform

• Für Funktionsaufrufe mit einem Parameter können Sie geschweifte Klammern anstelle von normalen Klammern verwenden - dies ermöglicht Ihnen (zusammen mit dem Curry) das Schreiben von Dingen wie

  val file = new File("example.txt")
  
  withPrintWriter(file) {
    writer => writer.println("this line is a function call parameter")
  }
  

  Dabei withPrintWriterhandelt es sich um eine einfache Methode mit zwei Parameterlisten, die jeweils einen einzelnen Parameter enthalten

• Mit Parametern nach Namen können Sie leere Parameterlisten in Lambdas weglassen und Anrufe wie myAssert(() => x > 3)in einer kürzeren Form als schreibenmyAssert(x > 3)

Die Erstellung eines DSL-Beispiels wird ausführlich in Kapitel 11 beschrieben. Domänenspezifische Sprachen in Scala aus dem kostenlosen Buch Programming Scala .

* _{Ich meine nicht, dass diese nur in Scala vorkommen, aber zumindest scheinen sie nicht sehr verbreitet zu sein. Ich bin jedoch kein Experte für funktionale Sprachen.}

Perl ermöglicht die Vorverarbeitung seiner Sprache. Dies wird zwar nicht oft verwendet, um die Syntax in der Sprache radikal zu ändern, ist jedoch in einigen der ... ungeraden Module zu sehen:

• Acme :: Bleach für wirklich sauberen Code
• Acme :: Morse zum Schreiben in Morsecode
• Lingua :: Romana :: Perligata für lateinisches Schreiben (zum Beispiel sind Substantive Variablen und Zahl, Groß- und Kleinschreibung und Deklination ändern den Typ des Substantivs nextum ==> $ next, nexta ==> @next)

Es gibt auch ein Modul, mit dem Perl Code ausführen kann, der aussieht, als wäre er in Python geschrieben worden.

Ein moderner Ansatz in Perl wäre die Verwendung von Filter :: Simple (eines der Kernmodule in Perl5).

Beachten Sie, dass es sich bei all diesen Beispielen um Damian Conway handelt, der als "Mad Doctor of Perl" bezeichnet wurde. Es ist immer noch eine erstaunlich mächtige Fähigkeit in Perl, die Sprache so zu verändern, wie man es will.

Weitere Dokumentation für diese und andere Alternativen finden Sie unter perlfilter .

Haskell

Haskell hat "Template Haskell" sowie "Quasiquotation":

http://www.haskell.org/haskellwiki/Template_Haskell

http://www.haskell.org/haskellwiki/Quasiquotation

Diese Funktionen ermöglichen es Benutzern, die Syntax der Sprache außerhalb der normalen Mittel dramatisch zu erweitern. Diese werden auch zur Kompilierungszeit behoben, was meiner Meinung nach ein großes Muss ist (zumindest für kompilierte Sprachen) [1].

Ich habe in Haskell schon einmal Quasiquotation verwendet, um einen erweiterten Mustervergleich für eine C-ähnliche Sprache zu erstellen:

moveSegment :: [Token] -> Maybe (SegPath, SegPath, [Token])
moveSegment [hc| HC_Move_Segment(@s, @s); | s1 s2 ts |] = Just (mkPath s1, mkPath s2, ts)
moveSegment _ = Nothing

[1] Andernfalls gilt Folgendes als Syntaxerweiterung: runFeature "some complicated grammar enclosed in a string to be evaluated at runtime"Dies ist natürlich eine Menge Mist.

Tcl unterstützt seit langem erweiterbare Syntax. Hier ist zum Beispiel die Implementierung einer Schleife, die drei Variablen (bis zum Stillstand) über die Kardinäle, ihre Quadrate und ihre Würfel iteriert:

proc loopCard23 {cardinalVar squareVar cubeVar body} {
    upvar 1 $cardinalVar cardinal $squareVar square $cubeVar cube

    # We borrow a 'for' loop for the implementation...
    for {set cardinal 0} true {incr cardinal} {
        set square [expr {$cardinal ** 2}]
        set cube [expr {$cardinal ** 3}]

        uplevel 1 $body
    }
}

Das würde dann so verwendet werden:

loopCard23 a b c {
    puts "got triplet: $a, $b, $c"
    if {$c > 400} {
        break
    }
}

Diese Art von Technik wird in der Tcl-Programmierung häufig verwendet. Der Schlüssel dazu sind die Befehle upvarund uplevel( upvarbindet eine benannte Variable in einem anderen Bereich an eine lokale Variable und uplevelführt ein Skript in einem anderen Bereich aus. In beiden Fällen 1zeigt das an der fragliche Bereich ist der Anrufer). Es wird auch häufig in Code verwendet, der mit Datenbanken gekoppelt ist (wobei Code für jede Zeile in einer Ergebnismenge ausgeführt wird), in Tk für GUIs (zum Binden von Rückrufen an Ereignisse) usw.

Dies ist jedoch nur ein Bruchteil dessen, was getan wird. Die eingebettete Sprache muss nicht einmal Tcl sein. es kann praktisch alles sein (solange es seine Klammern ausbalanciert - wenn das nicht stimmt, werden die Dinge syntaktisch schrecklich - das ist die enorme Mehrheit der Programme) und Tcl kann bei Bedarf einfach in die eingebettete Fremdsprache senden. Beispiele hierfür sind die Einbettung von C zur Implementierung von Tcl-Befehlen und das Äquivalent zu Fortran. (Vermutlich werden alle in Tcl integrierten Befehle auf diese Weise ausgeführt, da sie eigentlich nur eine Standardbibliothek sind und nicht die Sprache selbst.)

Dies ist zum Teil eine Frage der Semantik. Die Grundidee von Lisp ist, dass es sich bei dem Programm um Daten handelt, die selbst manipuliert werden können. Häufig verwendete Sprachen in der Lisp-Familie wie Scheme lassen Sie keine neue Syntax im Parser-Sinne hinzufügen . Es sind alles nur durch Leerzeichen begrenzte Listen in Klammern. Es ist nur so, dass Sie fast jedes semantische Konstrukt daraus machen können, da die Kernsyntax so wenig bewirkt . Scala (weiter unten beschrieben) ist ähnlich: Die Regeln für Variablennamen sind so liberal, dass Sie problemlos schöne DSLs daraus machen können (während Sie die gleichen Hauptsyntaxregeln einhalten).

Diese Sprachen ermöglichen zwar nicht das Definieren einer neuen Syntax im Sinne von Perl-Filtern, verfügen jedoch über einen ausreichend flexiblen Kern, mit dem Sie DSLs erstellen und Sprachkonstrukte hinzufügen können.

Das wichtige gemeinsame Merkmal ist, dass Sie damit sowohl funktionierende als auch integrierte Sprachkonstrukte definieren können, indem Sie Funktionen verwenden, die von den Sprachen verfügbar gemacht werden. Der Grad der Unterstützung für diese Funktion variiert:

• Viele ältere Sprachen haben eingebaute Funktionen wie sin(), round()etc. bereitgestellt , ohne eigene implementieren zu können.
• C ++ bietet eingeschränkte Unterstützung. Zum Beispiel einige integrierte Schlüsselwörter wie Abgüsse ( static_cast<target_type>(input), dynamic_cast<>(), const_cast<>(), reinterpret_cast<>()) können Template - Funktionen emuliert werden verwendet, die Boost - Anwendungen für lexical_cast<>(), polymorphic_cast<>(), any_cast<>(), ....
• Java verfügt über eine integrierte in Kontrollstrukturen ( for(;;){}, while(){}, if(){}else{}, do{}while(), synchronized(){}, strictfp{}) und nicht lassen Sie Ihre eigenen definieren. Scala definiert stattdessen eine abstrakte Syntax, mit der Sie Funktionen mithilfe einer praktischen Syntax wie bei einer Kontrollstruktur aufrufen können. Bibliotheken verwenden diese Syntax, um neue Kontrollstrukturen effektiv zu definieren (z. B. react{}in der Schauspielerbibliothek).

Möglicherweise sehen Sie sich auch die benutzerdefinierten Syntaxfunktionen von Mathematica im Notation-Paket an . (Technisch gesehen gehört es zur Lisp-Familie, hat jedoch einige Erweiterungsfunktionen anders ausgeführt als die übliche Lisp-Erweiterbarkeit.)

Rebol klingt fast wie das, was Sie beschreiben, aber ein bisschen seitwärts.

Anstatt eine bestimmte Syntax zu definieren, ist alles in Rebol ein Funktionsaufruf - es gibt keine Schlüsselwörter. (Ja, Sie können neu definieren ifund whilewenn Sie es wirklich wollen). Dies ist zum Beispiel eine ifAussage:

if now/time < 12:00 [print "Morning"]

ifist eine Funktion, die zwei Argumente akzeptiert: eine Bedingung und einen Block. Wenn die Bedingung erfüllt ist, wird der Block ausgewertet. Klingt nach den meisten Sprachen, oder? Nun, der Block ist eine Datenstruktur, er ist nicht auf Code beschränkt - dies ist beispielsweise ein Block von Blöcken und ein kurzes Beispiel für die Flexibilität von "Code ist Daten":

SomeArray: [ [foo "One"] [bar "Two"] [baz "Three"] ]
foreach action SomeArray [action/1: 'print] ; Change the data
if now/time < 12:00 SomeArray/2 ; Use the data as code - right now, if now/time < 12:00 [print "Two"]

Solange Sie sich an die Syntaxregeln halten können, ist das Erweitern dieser Sprache zum größten Teil nichts anderes als das Definieren neuer Funktionen. Einige Benutzer haben beispielsweise Funktionen von Rebol 3 in Rebol 2 zurückportiert.

Ruby hat eine recht flexible Syntax, ich denke, es ist eine Möglichkeit, "die Sprache innerhalb der Sprache selbst zu erweitern".

Ein Beispiel ist Rechen . Es ist in Ruby geschrieben, es ist Ruby, aber es sieht aus wie make .

Um einige Möglichkeiten zu prüfen, können Sie nach den Schlüsselwörtern Ruby und Metaprogramm suchen .

Wenn Sie die Syntax so erweitern, wie Sie es möchten, können Sie domänenspezifische Sprachen erstellen . Der vielleicht nützlichste Weg, um Ihre Frage neu zu formulieren, ist, welche anderen Sprachen eine gute Unterstützung für domänenspezifische Sprachen bieten.

Ruby hat eine sehr flexible Syntax, und viele DSLs, wie z. B. Rake, sind dort aufgetaucht. Groovy beinhaltet eine Menge dieser Güte. Es enthält auch AST-Transformationen, die den Lisp-Makros direkter entsprechen.

R, die Sprache für statistische Berechnungen, ermöglicht es Funktionen, ihre Argumente nicht zu bewerten. Damit wird eine DSL zur Angabe der Regressionsformel erstellt. Beispielsweise:

y ~ a + b

bedeutet "eine Linie der Form k0 + k1 * a + k2 * b an die Werte in y anpassen".

y ~ a * b

bedeutet "Passe eine Linie der Form k0 + k1 * a + k2 * b + k3 * a * b an die Werte in y an."

Und so weiter.

Converge ist eine weitere nicht-lispy Metaprogrammiersprache. In gewissem Maße ist auch C ++ geeignet.

Argumentieren, MetaOCaml ist ziemlich weit von Lisp. Für eine völlig andere Art der Syntaxerweiterung, aber dennoch sehr leistungsfähig, schauen Sie sich CamlP4 an .

Nemerle ist eine weitere erweiterbare Sprache mit einer Lisp-ähnlichen Metaprogrammierung, obwohl sie Sprachen wie Scala ähnlicher ist.

Und auch Scala selbst wird bald eine solche Sprache.

Edit: Ich habe das interessanteste Beispiel vergessen - JetBrains MPS . Es ist nicht nur sehr weit von Lispish entfernt, es ist sogar ein nicht-textuelles Programmiersystem mit einem Editor, der direkt auf AST-Ebene arbeitet.

Edit2: Um eine aktualisierte Frage zu beantworten - es gibt nichts Einzigartiges und Außergewöhnliches in den Lisp-Makros. Theoretisch kann jede Sprache einen solchen Mechanismus bieten (ich habe es sogar mit einfachem C gemacht). Alles, was Sie benötigen, ist ein Zugriff auf Ihren AST und die Fähigkeit, Code in der Kompilierungszeit auszuführen. Einige Überlegungen könnten hilfreich sein (Fragen nach den Typen, den vorhandenen Definitionen usw.).

In Prolog können neue Operatoren definiert werden, die in zusammengesetzte Begriffe mit demselben Namen übersetzt werden. Dies definiert beispielsweise einen has_catOperator und definiert ihn als Prädikat für die Überprüfung, ob eine Liste das Atom enthält cat:

:- op(500, xf, has_cat).
X has_cat :- member(cat, X).

?- [apple, cat, orange] has_cat.
true ;
false.

Das xfbedeutet, dass has_cates sich um einen Postfix-Operator handelt. Mit fxwürde es zu einem Präfixoperator und xfxmit zwei Argumenten zu einem Infixoperator. Weitere Informationen zum Definieren von Operatoren in Prolog finden Sie unter diesem Link .

TeX fehlt völlig in der Liste. Ihr alle wisst es, richtig? Es sieht ungefähr so ​​aus:

Some {\it ``interesting''} example.

… Außer dass Sie die Syntax ohne Einschränkungen neu definieren können. Jedem (!) Token in der Sprache kann eine neue Bedeutung zugewiesen werden. ConTeXt ist ein Makropaket, das geschweifte Klammern durch eckige Klammern ersetzt hat:

Some \it[``interesting''] example.

Das allgemeinere Makropaket LaTeX definiert auch die Sprache für seine Zwecke neu, z \begin{environment}…\end{environment}. B. durch Hinzufügen der Syntax.

Aber es hört hier nicht auf. Technisch gesehen können Sie die Token genauso gut neu definieren, um Folgendes zu analysieren:

Some <it>“interesting”</it> example.

Ja, absolut möglich Einige Pakete verwenden dies, um kleine domänenspezifische Sprachen zu definieren. Beispielsweise definiert das TikZ- Paket eine kurze Syntax für technische Zeichnungen, die Folgendes ermöglicht:

\foreach \angle in {0, 30, ..., 330} 
  \draw[line width=1pt] (\angle:0.82cm) -- (\angle:1cm);

Darüber hinaus ist TeX Turing komplett, so dass Sie buchstäblich alles damit machen können. Ich habe noch nie erlebt, wie das Potenzial voll ausgeschöpft wurde, weil es ziemlich sinnlos und sehr verworren wäre, aber es ist durchaus möglich, den folgenden Code nur durch Neudefinieren von Token syntaktisch analysierbar zu machen (dies würde jedoch wahrscheinlich aufgrund des Parsers an die physischen Grenzen gehen) wie es gebaut ist):

for word in [Some interesting example.]:
    if word == interesting:
        it(word)
    else:
        word

Mit Boo können Sie die Sprache während der Kompilierung mithilfe syntaktischer Makros stark anpassen.

Boo hat eine "erweiterbare Compiler-Pipeline". Dies bedeutet, dass der Compiler Ihren Code jederzeit während der Compiler-Pipeline aufrufen kann, um AST-Transformationen durchzuführen. Wie Sie wissen, handelt es sich bei Dingen wie Javas Generics oder C # -Linq lediglich um Syntaxtransformationen zur Kompilierungszeit. Dies ist also recht mächtig.

Der Hauptvorteil gegenüber Lisp ist, dass dies mit jeder Art von Syntax funktioniert. Boo verwendet eine Python-inspirierte Syntax, aber Sie könnten wahrscheinlich einen erweiterbaren Compiler mit einer C- oder Pascal-Syntax schreiben. Und da das Makro zur Kompilierungszeit ausgewertet wird, gibt es keine Leistungseinbußen.

Nachteile im Vergleich zu Lisp sind:

• Das Arbeiten mit einem AST ist nicht so elegant wie das Arbeiten mit S-Ausdrücken
• Da das Makro zur Kompilierungszeit aufgerufen wird, hat es keinen Zugriff auf Laufzeitdaten.

So können Sie beispielsweise eine neue Kontrollstruktur implementieren:

macro repeatLines(repeatCount as int, lines as string*):
    for line in lines:
        yield [| print $line * $repeatCount |]

Verwendung:

repeatLines 2, "foo", "bar"

welches dann zur Kompilierungszeit in etwas übersetzt wird, wie:

print "foo" * 2
print "bar" * 2

(Leider ist die Online-Dokumentation von Boo immer hoffnungslos veraltet und deckt nicht einmal fortgeschrittene Inhalte wie diese ab. Die beste Dokumentation für die Sprache, die ich kenne, ist dieses Buch: http://www.manning.com/rahien/ )

Die Auswertung von Mathematica basiert auf Mustererkennung und -ersetzung. Auf diese Weise können Sie Ihre eigenen Kontrollstrukturen erstellen, vorhandene Kontrollstrukturen ändern oder die Art und Weise ändern, in der Ausdrücke ausgewertet werden. Zum Beispiel könnten Sie "Fuzzy-Logik" wie folgt implementieren (etwas vereinfacht):

fuzzy[a_ && b_]      := Min[fuzzy[a], fuzzy[b]]
fuzzy[a_ || b_]      := Max[fuzzy[a], fuzzy[b]]
fuzzy[!a_]           := 1-fuzzy[a]
If[fuzzy[a_], b_,c_] := fuzzy[a] * fuzzy[b] + fuzzy[!a] * fuzzy[c]

Dies überschreibt die Auswertung für die vordefinierten logischen Operatoren &&, || ,! und die eingebaute IfKlausel.

Sie können diese Definitionen wie Funktionsdefinitionen lesen, aber die wahre Bedeutung ist: Wenn ein Ausdruck mit dem auf der linken Seite beschriebenen Muster übereinstimmt, wird er durch den Ausdruck auf der rechten Seite ersetzt. Sie können Ihre eigene If-Klausel wie folgt definieren:

myIf[True, then_, else_] := then
myIf[False, then_, else_] := else
SetAttributes[myIf, HoldRest]

SetAttributes[..., HoldRest] teilt dem Bewerter mit, dass er das erste Argument vor dem Mustervergleich auswerten soll, den Rest jedoch auswerten soll, bis das Muster abgeglichen und ersetzt wurde.

Dies wird in den Mathematica-Standardbibliotheken häufig verwendet, um z. B. eine Funktion zu definieren D, die einen Ausdruck aufnimmt und zu ihrer symbolischen Ableitung auswertet.

Metalua ist eine Sprache und ein Compiler, der mit Lua kompatibel ist und dies bietet.

• Volle Kompatibilität mit Lua 5.1-Quellen und Bytecode: saubere, elegante Semantik und Syntax, erstaunliche Ausdruckskraft, gute Leistungen, nahezu universelle Portabilität. - Ein vollständiges Makrosystem, ähnlich dem, was Lisp-Dialekte oder Template Haskell bieten. Manipulierte Programme können
  als Quellcode, als abstrakte Syntaxbäume oder als beliebige Mischung
  daraus betrachtet werden, je nachdem, was für Ihre Aufgabe besser geeignet ist.

• Ein dynamisch erweiterbarer Parser, mit dem Sie Ihre Makros mit einer Syntax unterstützen können, die sich gut in den Rest der Sprache einfügt.

• Eine Reihe von Spracherweiterungen, die alle als reguläre Metalua-Makros implementiert sind.

Unterschiede zu Lisp:

• Belästigen Sie Entwickler nicht mit Makros, wenn sie keine Makros schreiben: Die Syntax und Semantik der Sprache sollten in 95% der Fälle am besten geeignet sein, in denen wir keine Makros schreiben.
• Ermutigen Sie Entwickler, die Konventionen der Sprache zu befolgen: Nicht nur mit "Best Practices Rants", auf die niemand hört, sondern mit einer API, die es einfacher macht, Dinge auf Metalua-Weise zu schreiben. Die Lesbarkeit durch andere Entwickler ist wichtiger und schwieriger zu erreichen als die Lesbarkeit durch Compiler, und dafür ist es sehr hilfreich, über eine Reihe von anerkannten Konventionen zu verfügen.
• Stellen Sie jedoch alle Kräfte bereit, die Sie bereit sind, zu handhaben. Weder Lua noch Metalua sind zu Gebundenheit und Disziplin verpflichtet. Wenn Sie also wissen, was Sie tun, wird Ihnen die Sprache nicht in die Quere kommen.
• Machen Sie es deutlich, wenn etwas Interessantes passiert: Alle Meta-Operationen finden zwischen + {...} und - {...} statt und ragen optisch aus dem regulären Code heraus.

Ein Anwendungsbeispiel ist die Implementierung eines ML-ähnlichen Mustervergleichs.

Siehe auch: http://lua-users.org/wiki/MetaLua

Wenn Sie nach Sprachen suchen, die erweiterbar sind, sollten Sie sich Smalltalk ansehen.

In Smalltalk besteht die einzige Möglichkeit zum Programmieren darin, die Sprache tatsächlich zu erweitern. Es gibt keinen Unterschied zwischen der IDE, den Bibliotheken oder der Sprache. Sie sind alle so miteinander verwoben, dass Smalltalk oft als Umgebung und nicht als Sprache bezeichnet wird.

Sie schreiben keine eigenständigen Anwendungen in Smalltalk, sondern erweitern die Sprachumgebung.

Unter http://www.world.st/ finden Sie eine Handvoll Ressourcen und Informationen.

Ich möchte Pharo als Einstiegsdialekt in die Welt von Smalltalk empfehlen: http://pharo-project.org

Hoffe es hat geholfen!

Es gibt Tools, mit denen Sie benutzerdefinierte Sprachen erstellen können, ohne einen ganzen Compiler von Grund auf neu schreiben zu müssen. Zum Beispiel gibt es Spoofax , ein Codetransformationstool : Sie geben Eingabe-Grammatik- und -Transformationsregeln ein (deklarativ auf sehr hoher Ebene geschrieben) und können dann Java-Quellcode generieren (oder eine andere Sprache, wenn Sie dies wünschen). aus einer von Ihnen entworfenen Sprache.

Es wäre also möglich, die Grammatik der Sprache X zu übernehmen, die Grammatik der Sprache X '(X mit Ihren benutzerdefinierten Erweiterungen) und die Transformation X' → X zu definieren, und Spoofax generiert einen Compiler X '→ X.

Wenn ich das richtig verstehe, ist derzeit die beste Unterstützung für Java, wobei die C # -Unterstützung entwickelt wird (wie ich gehört habe). Diese Technik kann jedoch auf jede Sprache mit statischer Grammatik angewendet werden (z. B. wahrscheinlich nicht auf Perl ).

Forth ist eine andere Sprache, die sehr erweiterbar ist. Viele Forth-Implementierungen bestehen aus einem kleinen Kernel, der in Assembler oder C geschrieben ist, und der Rest der Sprache ist in Forth selbst geschrieben.

Es gibt auch mehrere stapelbasierte Sprachen, die von Forth inspiriert sind und diese Funktion gemeinsam haben, z. B. Factor .

Funge-98

Die Fingerabdruckfunktion von Funge-98 ermöglicht eine vollständige Umstrukturierung der gesamten Syntax und Semantik der Sprache. Dies ist jedoch nur möglich, wenn der Implementierer einen Fingerabdruckmechanismus bereitstellt, mit dem der Benutzer die Sprache programmgesteuert ändern kann (dies kann theoretisch innerhalb der normalen Funge-98-Syntax und -Semantik implementiert werden). In diesem Fall könnte man den Rest der Datei (oder beliebige Teile der Datei) buchstäblich als C ++ oder Lisp (oder was auch immer er will) verwenden.

http://quadium.net/funge/spec98.html#Fingerprints

Um das zu bekommen, wonach Sie suchen, benötigen Sie diese Klammern und eine fehlende Syntax. Ein paar syntaxbasierte Sprachen mögen nahe kommen, aber es ist nicht ganz dasselbe wie ein echtes Makro.