mal
1.0.0
1. Mal ist ein von Clojure inspirierter Lisp-Interpret
2. Mal ist ein Lernwerkzeug
Jede Mal-Implementierung ist in 11 inkrementelle, eigenständige (und testbare) Schritte unterteilt, die die Kernkonzepte von Lisp veranschaulichen. Der letzte Schritt ist die Fähigkeit zum Selbsthosting (Ausführen der mal-Implementierung von mal). Sehen Sie sich den Leitfaden zum Make-a-lisp-Prozess an.
Die Schritte zum Lispeln sind:
Zu jedem Make-a-Lisp-Schritt gehört ein Architekturdiagramm. Die für diesen Schritt neuen Elemente werden rot hervorgehoben. Hier ist die endgültige Architektur, sobald Schritt A abgeschlossen ist:
Wenn Sie daran interessiert sind, eine mal-Implementierung zu erstellen (oder einfach mal daran interessiert sind, mal für etwas zu verwenden), können Sie sich gerne unserem Discord anschließen. Zusätzlich zum Leitfaden zum Make-a-Lisp-Prozess gibt es auch eine Mal/Make-a-Lisp-FAQ, in der ich versuche, einige häufig gestellte Fragen zu beantworten.
3. Mal ist in 88 Sprachen implementiert (94 verschiedene Implementierungen und 117 Laufzeitmodi)
| Sprache | Schöpfer |
|---|---|
| Ada | Chris Moore |
| Ada #2 | Nicolas Boulenguez |
| GNU Awk | Mitsuru Kariya |
| Bash 4 | Joel Martin |
| BASIC (C64 & QBasic) | Joel Martin |
| BBC BASIC V | Ben Harris |
| C | Joel Martin |
| C #2 | Duncan Watts |
| C++ | Stephen Thirlwall |
| C# | Joel Martin |
| Futter | Vasilij Schneidermann |
| Clojure (Clojure & ClojureScript) | Joel Martin |
| CoffeeScript | Joel Martin |
| Gemeinsames Lispeln | Iqbal Ansari |
| Kristall | Linda_pp |
| D | Dov Murik |
| Pfeil | Harry Terkelsen |
| Elixier | Martin Ek |
| Ulme | Jos van Bakel |
| Emacs Lisp | Vasilij Schneidermann |
| Erlang | Nathan Fiedler |
| ES6 (ECMAScript 2015) | Joel Martin |
| F# | Peter Stephens |
| Faktor | Jordan Lewis |
| Fantom | Dov Murik |
| Fenchel | sogaiu |
| Weiter | Chris Houser |
| GNU Guile | Mu Lei |
| GNU Smalltalk | Vasilij Schneidermann |
| Gehen | Joel Martin |
| Groovig | Joel Martin |
| Haskell | Joel Martin |
| Haxe (Neko, Python, C++ und JS) | Joel Martin |
| Hy | Joel Martin |
| Io | Dov Murik |
| Janet | sogaiu |
| Java | Joel Martin |
| Java-Trüffel (Truffle/GraalVM) | Matt McGill |
| JavaScript (Demo) | Joel Martin |
| jq | Ali MohammadPur |
| Julia | Joel Martin |
| Kotlin | Javier Fernandez-Ivern |
| LaTeX3 | Nicolas Boulenguez |
| LiveScript | Jos van Bakel |
| Logo | Dov Murik |
| Lua | Joel Martin |
| GNU Make | Joel Martin |
| mal selbst | Joel Martin |
| MATLAB (GNU Octave & MATLAB) | Joel Martin |
| miniMAL (Repo, Demo) | Joel Martin |
| NASM | Ben Dudson |
| Nim | Dennis Felsing |
| Objekt Pascal | Joel Martin |
| Ziel C | Joel Martin |
| OCaml | Chris Houser |
| Perl | Joel Martin |
| Perl 6 | Hinrik Örn Sigurðsson |
| PHP | Joel Martin |
| Picolisp | Vasilij Schneidermann |
| Pike | Dov Murik |
| PL/pgSQL (PostgreSQL) | Joel Martin |
| PL/SQL (Oracle) | Joel Martin |
| PostScript | Joel Martin |
| PowerShell | Joel Martin |
| Prolog | Nicolas Boulenguez |
| PureScript | mrsekut |
| Python2 | Joel Martin |
| Python3 | Gavin Lewis |
| RPython | Joel Martin |
| R | Joel Martin |
| Schläger | Joel Martin |
| Rexx | Dov Murik |
| Rubin | Joel Martin |
| Rubin #2 | Ryan Cook |
| Rost | Joel Martin |
| Scala | Joel Martin |
| Schema (R7RS) | Vasilij Schneidermann |
| Schräg | Dov Murik |
| Standard-ML | Fabian Bergström |
| Schnell 3 | Joel Martin |
| Schnell 4 | 陆遥 |
| Swift 6 | Oleg Montak |
| Tcl | Dov Murik |
| Typoskript | Masahiro Wakame |
| Vala | Simon Tatham |
| VHDL | Dov Murik |
| Vimscript | Dov Murik |
| Visual Basic.NET | Joel Martin |
| Visual Basic-Skript | 刘百超 |
| WebAssembly (wasm) | Joel Martin |
| Zaunkönig | Dov Murik |
| XSLT | Ali MohammadPur |
| Yorick | Dov Murik |
| Zig | Josh Tobin |
Mal wurde erstmals öffentlich in einem Lightning Talk auf der Clojure West 2014 vorgestellt (leider gibt es kein Video). Siehe „examples/clojurewest2014.mal“ für die Präsentation, die auf der Konferenz gehalten wurde (ja, die Präsentation ist ein Malprogramm).
Auf der Midwest.io 2015 hielt Joel Martin einen Vortrag über Mal mit dem Titel „Achievement Unlocked: A Better Path to Language Learning“. Video, Folien.
Vor Kurzem hielt Joel auf der LambdaConf 2016 einen Vortrag zum Thema „Make Your Own Lisp Interpreter in 10 Incremental Steps“: Teil 1, Teil 2, Teil 3, Teil 4, Folien.
Der einfachste Weg, eine bestimmte Implementierung auszuführen, ist die Verwendung von Docker. Jede Implementierung verfügt über ein vorgefertigtes Docker-Image mit installierten Sprachabhängigkeiten. Sie können REPL über ein praktisches Ziel im Makefile der obersten Ebene starten (wobei IMPL der Name des Implementierungsverzeichnisses und stepX der auszuführende Schritt ist):
make DOCKERIZE=1 "repl^IMPL^stepX"
# OR stepA is the default step:
make DOCKERIZE=1 "repl^IMPL"
Die folgenden Implementierungen werden als separate Projekte gepflegt:
Die Ada-Implementierung wurde mit GNAT 4.9 auf Debian entwickelt. Es lässt sich auch unter Windows unverändert kompilieren, wenn Sie Windows-Versionen von Git, GNAT und (optional) Make haben. Es gibt keine externen Abhängigkeiten (readline nicht implementiert).
cd impls/ada
make
./stepX_YYY
Die zweite Ada-Implementierung wurde mit GNAT 8 entwickelt und ist mit der GNU-Readline-Bibliothek verknüpft.
cd impls/ada
make
./stepX_YYY
Die GNU awk-Implementierung von mal wurde mit GNU awk 4.1.1 getestet.
cd impls/gawk
gawk -O -f stepX_YYY.awk
cd impls/bash
bash stepX_YYY.sh
Die BASIC-Implementierung verwendet einen Präprozessor, der BASIC-Code generieren kann, der sowohl mit C64 BASIC (CBM v2) als auch mit QBasic kompatibel ist. Der C64-Modus wurde mit cbmbasic getestet (die gepatchte Version ist derzeit erforderlich, um Probleme mit der Zeileneingabe zu beheben) und der QBasic-Modus wurde mit FreeBASIC getestet.
Generieren Sie C64-Code und führen Sie ihn mit cbmbasic aus:
cd impls/basic
make MODE=cbm stepX_YYY.bas
STEP=stepX_YYY basic_MODE=cbm ./run
QBasic-Code generieren, mit FreeBASIC kompilieren und ausführen:
cd impls/basic
make MODE=qbasic stepX_YYY.bas
make MODE=qbasic stepX_YYY
./stepX_YYY
Vielen Dank an Steven Syrek für die ursprüngliche Inspiration für diese Umsetzung.
Die BBC BASIC V-Implementierung kann im Brandy-Interpreter ausgeführt werden:
cd impls/bbc-basic
brandy -quit stepX_YYY.bbc
Oder in ARM BBC BASIC V unter RISC OS 3 oder höher:
*Dir bbc-basic.riscos
*Run setup
*Run stepX_YYY
Die C-Implementierung von mal erfordert die folgenden Bibliotheken (lib- und Header-Pakete): glib, libffi6, libgc und entweder die libedit- oder GNU-readline-Bibliothek.
cd impls/c
make
./stepX_YYY
Die zweite C-Implementierung von mal erfordert die folgenden Bibliotheken (lib- und Header-Pakete): libedit, libgc, libdl und libffi.
cd impls/c.2
make
./stepX_YYY
Die C++-Implementierung von mal erfordert zum Erstellen g++-4.9 oder clang++-3.5 und eine readline-kompatible Bibliothek. Weitere Details finden Sie in cpp/README.md :
cd impls/cpp
make
# OR
make CXX=clang++-3.5
./stepX_YYY
Die C#-Implementierung von mal wurde unter Linux mit dem Mono C#-Compiler (mcs) und der Mono-Laufzeitumgebung (Version 2.10.8.1) getestet. Beide sind erforderlich, um die C#-Implementierung zu erstellen und auszuführen.
cd impls/cs
make
mono ./stepX_YYY.exe
Die ChucK-Implementierung wurde mit ChucK 1.3.5.2 getestet.
cd impls/chuck
./run
Für die Clojure-Implementierung ist größtenteils Clojure 1.5 erforderlich. Um alle Tests zu bestehen, ist jedoch Clojure 1.8.0-RC4 erforderlich.
cd impls/clojure
lein with-profile +stepX trampoline run
sudo npm install -g coffee-script
cd impls/coffee
coffee ./stepX_YYY
Die Implementierung wurde mit SBCL, CCL, CMUCL, GNU CLISP, ECL und Allegro CL auf Ubuntu 16.04 und Ubuntu 12.04 getestet. Weitere Details finden Sie in der README-Datei. Sofern Sie die genannten Abhängigkeiten installiert haben, führen Sie die folgenden Schritte aus, um die Implementierung auszuführen
cd impls/common-lisp
make
./run
Die Crystal-Implementierung von mal wurde mit Crystal 0.26.1 getestet.
cd impls/crystal
crystal run ./stepX_YYY.cr
# OR
make # needed to run tests
./stepX_YYY
Die D-Implementierung von mal wurde mit GDC 4.8 getestet. Es erfordert die GNU-Readline-Bibliothek.
cd impls/d
make
./stepX_YYY
Die Dart-Implementierung wurde mit Dart 1.20 getestet.
cd impls/dart
dart ./stepX_YYY
Die Emacs Lisp-Implementierung von mal wurde mit Emacs 24.3 und 24.5 getestet. Während es eine sehr einfache Lesezeilenbearbeitung gibt ( <backspace> und Cd funktionieren, Cc bricht den Vorgang ab), wird die Verwendung von rlwrap empfohlen.
cd impls/elisp
emacs -Q --batch --load stepX_YYY.el
# with full readline support
rlwrap emacs -Q --batch --load stepX_YYY.el
Die Elixir-Implementierung von mal wurde mit Elixir 1.0.5 getestet.
cd impls/elixir
mix stepX_YYY
# Or with readline/line editing functionality:
iex -S mix stepX_YYY
Die Elm-Implementierung von mal wurde mit Elm 0.18.0 getestet
cd impls/elm
make stepX_YYY.js
STEP=stepX_YYY ./run
Die Erlang-Implementierung von mal erfordert zum Erstellen Erlang/OTP R17 und Rebar.
cd impls/erlang
make
# OR
MAL_STEP=stepX_YYY rebar compile escriptize # build individual step
./stepX_YYY
Die ES6/ECMAScript 2015-Implementierung verwendet den Babel-Compiler, um ES5-kompatibles JavaScript zu generieren. Der generierte Code wurde mit Node 0.12.4 getestet.
cd impls/es6
make
node build/stepX_YYY.js
Die F#-Implementierung von mal wurde unter Linux mit dem Mono F#-Compiler (fsharpc) und der Mono-Laufzeitumgebung (Version 3.12.1) getestet. Der Mono-C#-Compiler (mcs) ist außerdem erforderlich, um die Readline-Abhängigkeit zu kompilieren. Alle sind zum Erstellen und Ausführen der F#-Implementierung erforderlich.
cd impls/fsharp
make
mono ./stepX_YYY.exe
Die Factor-Implementierung von mal wurde mit Faktor 0,97 getestet (factorcode.org).
cd impls/factor
FACTOR_ROOTS=. factor -run=stepX_YYY
Die Fantom-Implementierung von mal wurde mit Fantom 1.0.70 getestet.
cd impls/fantom
make lib/fan/stepX_YYY.pod
STEP=stepX_YYY ./run
Die Fennel-Implementierung von mal wurde mit Fennel Version 0.9.1 auf Lua 5.4 getestet.
cd impls/fennel
fennel ./stepX_YYY.fnl
cd impls/forth
gforth stepX_YYY.fs
cd impls/guile
guile -L ./ stepX_YYY.scm
Die Smalltalk-Implementierung von mal wurde mit GNU Smalltalk 3.2.91 getestet.
cd impls/gnu-smalltalk
./run
Die Go-Implementierung von mal erfordert, dass go auf dem Pfad installiert ist. Die Implementierung wurde mit Go 1.3.1 getestet.
cd impls/go
make
./stepX_YYY
Die Groovy-Implementierung von mal erfordert die Ausführung von Groovy und wurde mit Groovy 1.8.6 getestet.
cd impls/groovy
make
groovy ./stepX_YYY.groovy
Die Haskell-Implementierung erfordert den GHC-Compiler Version 7.10.1 oder höher sowie die Haskell-Pakete Parsec und Readline (oder Editline).
cd impls/haskell
make
./stepX_YYY
Die Haxe-Implementierung von mal erfordert zum Kompilieren die Haxe-Version 3.2. Es werden vier verschiedene Haxe-Ziele unterstützt: Neko, Python, C++ und JavaScript.
cd impls/haxe
# Neko
make all-neko
neko ./stepX_YYY.n
# Python
make all-python
python3 ./stepX_YYY.py
# C++
make all-cpp
./cpp/stepX_YYY
# JavaScript
make all-js
node ./stepX_YYY.js
Die Hy-Implementierung von mal wurde mit Hy 0.13.0 getestet.
cd impls/hy
./stepX_YYY.hy
Die Io-Implementierung von mal wurde mit der Io-Version 20110905 getestet.
cd impls/io
io ./stepX_YYY.io
Die Janet-Implementierung von mal wurde mit Janet Version 1.12.2 getestet.
cd impls/janet
janet ./stepX_YYY.janet
Die Java-Implementierung von mal erfordert zum Erstellen maven2.
cd impls/java
mvn compile
mvn -quiet exec:java -Dexec.mainClass=mal.stepX_YYY
# OR
mvn -quiet exec:java -Dexec.mainClass=mal.stepX_YYY -Dexec.args="CMDLINE_ARGS"
Diese Java-Implementierung läuft auf OpenJDK, kann aber dank des Truffle-Frameworks bis zu 30-mal schneller auf GraalVM laufen. Es wurde mit OpenJDK 11, GraalVM CE 20.1.0 und GraalVM CE 21.1.0 getestet.
cd impls/java-truffle
./gradlew build
STEP=stepX_YYY ./run
cd impls/js
npm install
node stepX_YYY.js
Die Julia-Implementierung von mal erfordert Julia 0.4.
cd impls/julia
julia stepX_YYY.jl
Getestet mit Version 1.6, mit viel Betrug in der IO-Abteilung
cd impls/jq
STEP=stepA_YYY ./run
# with Debug
DEBUG=true STEP=stepA_YYY ./run
Die Kotlin-Implementierung von mal wurde mit Kotlin 1.0 getestet.
cd impls/kotlin
make
java -jar stepX_YYY.jar
Die LaTeX3-Implementierung von mal wurde mit pdfTeX 3.141592653-2.6-1.40.24 getestet.
Das Selbsthosting ist für eine sinnvolle Zeitüberschreitung zu langsam und stürzt in Schritt 4 ab, offenbar aufgrund fest codierter Einschränkungen.
Jeder, der daran arbeitet, sollte die beiden Zeilen mit (langsamen) Debugging-Optionen in der Schrittdatei auskommentieren und DEBUG=1 exportieren (für mehr Ausgabe, als die Tests akzeptieren).
Die LiveScript-Implementierung von mal wurde mit LiveScript 1.5 getestet.
cd impls/livescript
make
node_modules/.bin/lsc stepX_YYY.ls
Die Logo-Implementierung von mal wurde mit UCBLogo 6.0 getestet.
cd impls/logo
logo stepX_YYY.lg
Die Lua-Implementierung von mal wurde mit Lua 5.3.5 getestet. Die Implementierung erfordert die Installation von Luarocks.
cd impls/lua
make # to build and link linenoise.so and rex_pcre.so
./stepX_YYY.lua
Das Ausführen der Mal-Implementierung von Mal umfasst das Ausführen von Schritt A einer der anderen Implementierungen und die Übergabe des Mal-Schritts zur Ausführung als Befehlszeilenargument.
cd impls/IMPL
IMPL_STEPA_CMD ../mal/stepX_YYY.mal
cd impls/make
make -f stepX_YYY.mk
Die NASM-Implementierung von mal ist für x86-64-Linux geschrieben und wurde mit Linux 3.16.0-4-amd64 und NASM-Version 2.11.05 getestet.
cd impls/nasm
make
./stepX_YYY
Die Nim-Implementierung von mal wurde mit Nim 1.0.4 getestet.
cd impls/nim
make
# OR
nimble build
./stepX_YYY
Die Object Pascal-Implementierung von mal wurde unter Linux mit den Free Pascal-Compilern Version 2.6.2 und 2.6.4 erstellt und getestet.
cd impls/objpascal
make
./stepX_YYY
Die Objective-C-Implementierung von mal wurde unter Linux mit clang/LLVM 3.6 erstellt und getestet. Es wurde auch unter OS X mit Xcode 7 erstellt und getestet.
cd impls/objc
make
./stepX_YYY
cd impls/ocaml
make
./stepX_YYY
Die MatLab-Implementierung wurde mit GNU Octave 4.2.1 getestet. Es wurde auch mit der MATLAB-Version R2014a unter Linux getestet. Beachten Sie, dass MATLAB ein kommerzielles Produkt ist.
cd impls/matlab
./stepX_YYY
octave -q --no-gui --no-history --eval "stepX_YYY();quit;"
matlab -nodisplay -nosplash -nodesktop -nojvm -r "stepX_YYY();quit;"
# OR with command line arguments
octave -q --no-gui --no-history --eval "stepX_YYY('arg1','arg2');quit;"
matlab -nodisplay -nosplash -nodesktop -nojvm -r "stepX_YYY('arg1','arg2');quit;"
miniMAL ist ein kleiner Lisp-Interpreter, der in weniger als 1024 Byte JavaScript implementiert ist. Um die miniMAL-Implementierung von mal auszuführen, müssen Sie den miniMAL-Interpreter herunterladen/installieren (der Node.js erfordert).
cd impls/miniMAL
# Download miniMAL and dependencies
npm install
export PATH=`pwd`/node_modules/minimal-lisp/:$PATH
# Now run mal implementation in miniMAL
miniMAL ./stepX_YYY
Die Perl 5-Implementierung sollte mit Perl 5.19.3 und höher funktionieren.
Um die Bearbeitung von Readline-Zeilen zu unterstützen, installieren Sie Term::ReadLine::Perl oder Term::ReadLine::Gnu von CPAN.
cd impls/perl
perl stepX_YYY.pl
Die Perl 6-Implementierung wurde auf Rakudo Perl 6 2016.04 getestet.
cd impls/perl6
perl6 stepX_YYY.pl
Die PHP-Implementierung von mal erfordert die Ausführung der PHP-Befehlszeilenschnittstelle.
cd impls/php
php stepX_YYY.php
Die Picolisp-Implementierung erfordert libreadline und Picolisp 3.1.11 oder höher.
cd impls/picolisp
./run
Die Pike-Implementierung wurde auf Pike 8.0 getestet.
cd impls/pike
pike stepX_YYY.pike
Die PL/pgSQL-Implementierung von mal erfordert einen laufenden PostgreSQL-Server (das Docker-Image „kanaka/mal-test-plpgsql“ startet automatisch einen PostgreSQL-Server). Die Implementierung stellt eine Verbindung zum PostgreSQL-Server her und erstellt eine Datenbank mit dem Namen „mal“, um Tabellen und gespeicherte Prozeduren zu speichern. Das Wrapper-Skript verwendet den psql-Befehl, um eine Verbindung zum Server herzustellen und verwendet standardmäßig den Benutzer „postgres“, dieser kann jedoch mit der Umgebungsvariablen PSQL_USER überschrieben werden. Mit der Umgebungsvariablen PGPASSWORD kann ein Passwort angegeben werden. Die Implementierung wurde mit PostgreSQL 9.4 getestet.
cd impls/plpgsql
./wrap.sh stepX_YYY.sql
# OR
PSQL_USER=myuser PGPASSWORD=mypass ./wrap.sh stepX_YYY.sql
Die PL/SQL-Implementierung von mal erfordert einen laufenden Oracle-DB-Server (das Docker-Image „kanaka/mal-test-plsql“ startet automatisch einen Oracle Express-Server). Die Implementierung stellt eine Verbindung zum Oracle-Server her, um Typen, Tabellen und gespeicherte Prozeduren zu erstellen. Der standardmäßige SQL*Plus-Anmeldewert (Benutzername/Passwort@connect_identifier) ist „system/oracle“, dieser kann jedoch mit der Umgebungsvariablen ORACLE_LOGON überschrieben werden. Die Implementierung wurde mit Oracle Express Edition 11g Release 2 getestet. Beachten Sie, dass alle SQL*Plus-Verbindungswarnungen (Ablauf des Benutzerkennworts usw.) die Fähigkeit des Wrapper-Skripts beeinträchtigen, mit der Datenbank zu kommunizieren.
cd impls/plsql
./wrap.sh stepX_YYY.sql
# OR
ORACLE_LOGON=myuser/mypass@ORCL ./wrap.sh stepX_YYY.sql
Die PostScript-Implementierung von mal erfordert die Ausführung von Ghostscript. Es wurde mit Ghostscript 9.10 getestet.
cd impls/ps
gs -q -dNODISPLAY -I./ stepX_YYY.ps
Die PowerShell-Implementierung von mal erfordert die PowerShell-Skriptsprache. Es wurde mit PowerShell 6.0.0 Alpha 9 unter Linux getestet.
cd impls/powershell
powershell ./stepX_YYY.ps1
Die Prolog-Implementierung verwendet einige für SWI-Prolog spezifische Konstrukte, beinhaltet Readline-Unterstützung und wurde unter Debian GNU/Linux mit Version 8.2.1 getestet.
cd impls/prolog
swipl stepX_YYY
Die PureScript-Implementierung erfordert die Spago-Compiler-Version 0.20.2.
cd impls/purs
make
node ./stepX_YYY.js
Diese Implementierung verwendet nur Python2-Funktionen, vermeidet jedoch Inkompatibilitäten mit Python3.
Diese Implementierung wird auf Stil und Typen überprüft (flake8, pylint, mypy). Es meldet alle Fehler mit Details. Es demonstriert Iteratoren, Dekoratoren, Funktionswerkzeuge, Kettenkarten, Datenklassen, Selbstbeobachtung, Übereinstimmungsanweisungen und Zuweisungsausdrücke.
Sie müssen Python auf Ihrem Pfad haben (im Lieferumfang von Pypy enthalten).
cd impls/rpython
make # this takes a very long time
./stepX_YYY
Die R-Implementierung von mal erfordert die Ausführung von R (r-base-core).
cd impls/r
make libs # to download and build rdyncall
Rscript stepX_YYY.r
Die Racket-Implementierung von mal erfordert die Ausführung des Racket-Compilers/Interpreters.
cd impls/racket
./stepX_YYY.rkt
Die Rexx-Implementierung von mal wurde mit Regina Rexx 3.6 getestet.
cd impls/rexx
make
rexx -a ./stepX_YYY.rexxpp
cd impls/ruby
ruby stepX_YYY.rb
Eine zweite Ruby-Implementierung mit folgenden Zielen:
Mal -Modul-Namespace cd impls/ruby.2
ruby stepX_YYY.rb
Die Rust-Implementierung von Mal erfordert zum Erstellen den Rust-Compiler und das Build-Tool (Cargo).
cd impls/rust
cargo run --release --bin stepX_YYY
Installieren Sie scala und sbt (http://www.scala-sbt.org/0.13/tutorial/Installing-sbt-on-Linux.html):
cd impls/scala
sbt 'run-main stepX_YYY'
# OR
sbt compile
scala -classpath target/scala*/classes stepX_YYY
Die Scheme-Implementierung von MAL wurde mit Chibi-Scheme 0.10, Kawa 3.1.1, Gauche 0.9.6, CHICKEN 5.1.0, Sagittarius 0.9.7, Cyclone 0.32.0 (Git-Version) und Foment 0.4 (Git-Version) getestet. Sie sollten es auf anderen konformen R7RS-Implementierungen zum Laufen bringen können, nachdem Sie herausgefunden haben, wie Bibliotheken geladen werden, und das Makefile anpassen und das Skript entsprechend run .
cd impls/scheme
# chibi
scheme_MODE=chibi ./run
# kawa
make kawa
scheme_MODE=kawa ./run
# gauche
scheme_MODE=gauche ./run
# chicken
make chicken
scheme_MODE=chicken ./run
# sagittarius
scheme_MODE=sagittarius ./run
# cyclone
make cyclone
scheme_MODE=cyclone ./run
# foment
scheme_MODE=foment ./run
Die Skew-Implementierung von mal wurde mit Skew 0.7.42 getestet.
cd impls/skew
make
node stepX_YYY.js
Die Standard-ML-Implementierung von mal erfordert eine SML97-Implementierung. Das Makefile unterstützt Poly/ML, MLton, Moscow ML und wurde mit Poly/ML 5.8.1, MLton 20210117 und Moscow ML Version 2.10 getestet.
cd impls/sml
# Poly/ML
make sml_MODE=polyml
./stepX_YYY
# MLton
make sml_MODE=mlton
./stepX_YYY
# Moscow ML
make sml_MODE=mosml
./stepX_YYY
Die Swift 3-Implementierung von mal erfordert den Swift 3.0-Compiler. Es wurde mit Swift 3 Preview 3 getestet.
cd impls/swift3
make
./stepX_YYY
Die Swift 4-Implementierung von mal erfordert den Swift 4.0-Compiler. Es wurde mit der Swift-Version 4.2.3 getestet.
cd impls/swift4
make
./stepX_YYY
Die Swift 5-Implementierung von mal erfordert den Swift 5.0-Compiler. Es wurde mit Swift 5.1.1 getestet.
cd impls/swift6
swift run stepX_YYY
Für die Tcl-Implementierung von mal ist Tcl 8.6 erforderlich. Um die Bearbeitung von Readline-Zeilen zu unterstützen, installieren Sie tclreadline.
cd impls/tcl
tclsh ./stepX_YYY.tcl
Die TypeScript-Implementierung von mal erfordert den TypeScript 2.2-Compiler. Es wurde mit Node.js v6 getestet.
cd impls/ts
make
node ./stepX_YYY.js
Die Vala-Implementierung von mal wurde mit dem Vala 0.40.8-Compiler getestet. Sie müssen valac und libreadline-dev oder gleichwertiges installieren.
cd impls/vala
make
./stepX_YYY
Die VHDL-Implementierung von mal wurde mit GHDL 0.29 getestet.
cd impls/vhdl
make
./run_vhdl.sh ./stepX_YYY
Für die Vimscript-Implementierung von mal ist Vim 8.0 erforderlich.
cd impls/vimscript
./run_vimscript.sh ./stepX_YYY.vim
Die VB.NET-Implementierung von mal wurde unter Linux mit dem Mono VB-Compiler (vbnc) und der Mono-Laufzeitumgebung (Version 2.10.8.1) getestet. Beide sind zum Erstellen und Ausführen der VB.NET-Implementierung erforderlich.
cd impls/vb
make
mono ./stepX_YYY.exe
Die VBScript-Implementierung von mal wurde unter Windows 10 1909 getestet. install.vbs kann Ihnen bei der Installation der Anforderungen helfen (.NET 2.0 3.0 3.5). Wenn Sie .NET 2.0 3.0 3.5 nicht installiert haben, wird ein Fenster zur Installation angezeigt. Wenn Sie das bereits installiert haben, wird es nichts bewirken.
cd implsvbs
install.vbs
cscript -nologo stepX_YYY.vbs
Die WebAssembly-Implementierung ist in Wam (WebAssembly-Makrosprache) geschrieben und läuft unter mehreren verschiedenen Nicht-Web-Einbettungen (Laufzeiten): Node, Wasmtime, Wasmer, Wax, Wace, Warpy.
cd impls/wasm
# node
make wasm_MODE=node
./run.js ./stepX_YYY.wasm
# wasmtime
make wasm_MODE=wasmtime
wasmtime --dir=./ --dir=../ --dir=/ ./stepX_YYY.wasm
# wasmer
make wasm_MODE=wasmer
wasmer run --dir=./ --dir=../ --dir=/ ./stepX_YYY.wasm
# wax
make wasm_MODE=wax
wax ./stepX_YYY.wasm
# wace
make wasm_MODE=wace_libc
wace ./stepX_YYY.wasm
# warpy
make wasm_MODE=warpy
warpy --argv --memory-pages 256 ./stepX_YYY.wasm
Die XSLT-Implementierung von mal wurde mit XSLT 3 geschrieben und auf Saxon 9.9.1.6 Home Edition getestet.
cd impls/xslt
STEP=stepX_YY ./run
Die Wren-Implementierung von mal wurde auf Wren 0.2.0 getestet.
cd impls/wren
wren ./stepX_YYY.wren
Die Yorick-Implementierung von mal wurde auf Yorick 2.2.04 getestet.
cd impls/yorick
yorick -batch ./stepX_YYY.i
Die Zig-Implementierung von mal wurde auf Zig 0.5 getestet.
cd impls/zig
zig build stepX_YYY
Das Makefile der obersten Ebene verfügt über eine Reihe nützlicher Ziele, die bei der Implementierungsentwicklung und beim Testen hilfreich sind. Das help bietet eine Liste der Ziele und Optionen:
make help
Im Verzeichnis tests/ befinden sich fast 800 generische Funktionstests (für alle Implementierungen). Für jeden Schritt gibt es eine entsprechende Testdatei, die für diesen Schritt spezifische Tests enthält. Die Testumgebung runtest.py startet eine Mal-Step-Implementierung, leitet die Tests dann einzeln an die Implementierung weiter und vergleicht den Ausgabe-/Rückgabewert mit dem erwarteten Ausgabe-/Rückgabewert.
make test
make "test^IMPL"
# e.g.
make "test^clojure"
make "test^js"
make "test^stepX"
# e.g.
make "test^step2"
make "test^step7"
make "test^IMPL^stepX"
# e.g
make "test^ruby^step3"
make "test^ps^step4"
mal als Testimplementierung an und verwenden die Make-Variable MAL_IMPL , um die zugrunde liegende Hostsprache zu ändern (Standard ist JavaScript): make MAL_IMPL=IMPL "test^mal^step2"
# e.g.
make "test^mal^step2" # js is default
make MAL_IMPL=ruby "test^mal^step2"
make MAL_IMPL=python3 "test^mal^step2"
make "repl^IMPL^stepX"
# e.g
make "repl^ruby^step3"
make "repl^ps^step4"
stepA verwendet: make "repl^IMPL"
# e.g
make "repl^ruby"
make "repl^ps"
mal als REPL-Implementierung an und verwenden Sie die Make-Variable MAL_IMPL , um die zugrunde liegende Hostsprache zu ändern (Standard ist JavaScript): make MAL_IMPL=IMPL "repl^mal^stepX"
# e.g.
make "repl^mal^step2" # js is default
make MAL_IMPL=ruby "repl^mal^step2"
make MAL_IMPL=python3 "repl^mal"
Warnung: Diese Leistungstests sind weder statistisch valide noch umfassend; Die Laufzeitleistung ist kein primäres Ziel von Mal. Wenn Sie aus diesen Leistungstests ernsthafte Schlussfolgerungen ziehen, kontaktieren Sie mich bitte bezüglich einer fantastischen Immobilie direkt am Meer in Kansas, die ich Ihnen gerne zu einem günstigen Preis verkaufen würde.
make "perf^IMPL"
# e.g.
make "perf^js"
make "perf"
make "stats^IMPL"
# e.g.
make "stats^js"
Jedes Implementierungsverzeichnis enthält eine Docker-Datei zum Erstellen eines Docker-Images, das alle Abhängigkeiten für diese Implementierung enthält. Darüber hinaus enthält das Makefile der obersten Ebene Unterstützung für die Ausführung des Testziels (und von Perf, Stats, Repl usw.) in einem Docker-Container für diese Implementierung durch Übergabe von „DOCKERIZE=1“ in der Make-Befehlszeile. Zum Beispiel:
make DOCKERIZE=1 "test^js^step3"
Bei vorhandenen Implementierungen sind bereits Docker-Images erstellt und in die Docker-Registrierung übertragen worden. Wenn Sie jedoch ein Docker-Image lokal erstellen oder neu erstellen möchten, stellt das Makefile der obersten Ebene eine Regel zum Erstellen von Docker-Images bereit:
make "docker-build^IMPL"
Hinweise :
make DOCKERIZE=1 "repl^IMPL" bevor Sie Tests ausführen können, da Laufzeitabhängigkeiten heruntergeladen werden müssen, um dies zu vermeiden Zeitüberschreitung bei Tests. Diese Abhängigkeiten werden in Dot-Dateien im Verzeichnis /mal heruntergeladen, sodass sie zwischen den Ausführungen bestehen bleiben. Mal (make-a-lisp) ist unter der MPL 2.0 (Mozilla Public License 2.0) lizenziert. Weitere Informationen finden Sie in LICENSE.txt.
