mal
1.0.0
1. Mal est un interprète Lisp inspiré de Clojure
2. Mal est un outil d'apprentissage
Chaque implémentation de mal est séparée en 11 étapes incrémentielles, autonomes (et testables) qui démontrent les concepts fondamentaux de Lisp. La dernière étape est capable de s'auto-héberger (exécuter l'implémentation mal de mal). Consultez le guide du processus make-a-lisp.
Les étapes de création d'un lisp sont :
Chaque étape make-a-lisp est associée à un diagramme architectural. Les éléments nouveaux pour cette étape sont surlignés en rouge. Voici l’architecture finale une fois l’étape A terminée :
Si vous souhaitez créer une implémentation mal (ou simplement utiliser mal pour quelque chose), vous êtes invités à rejoindre notre Discord. En plus du guide du processus make-a-lisp, il existe également une FAQ mal/make-a-lisp dans laquelle j'essaie de répondre à quelques questions courantes.
3. Mal est implémenté dans 88 langages (94 implémentations différentes et 117 modes d'exécution)
| Langue | Créateur |
|---|---|
| Ada | Chris Moore |
| Ada #2 | Nicolas Boulenguez |
| GNU Awk | Mitsuru Kariya |
| Coup 4 | Joël Martin |
| BASIQUE (C64 et QBasic) | Joël Martin |
| BBC BASE V | Ben Harris |
| C | Joël Martin |
| C#2 | Duncan Watts |
| C++ | Stephen Thirlwall |
| C# | Joël Martin |
| Mandrin | Vassili Schneidermann |
| Clojure (Clojure et ClojureScript) | Joël Martin |
| CaféScript | Joël Martin |
| Lisp commun | Iqbal Ansari |
| Cristal | Linda_pp |
| D | Dov Murik |
| Dard | Harry Terkelsen |
| Élixir | Martin Ek |
| Orme | Jos van Bakel |
| Emacs Lisp | Vassili Schneidermann |
| Erlang | Nathan Fidler |
| ES6 (ECMAScript 2015) | Joël Martin |
| Fa# | Peter Stephens |
| Facteur | Jordan Lewis |
| Fantôme | Dov Murik |
| Fenouil | Sogaiu |
| En avant | Chris Houser |
| GNU Guile | Mu Lei |
| GNU Smalltalk | Vassili Schneidermann |
| Aller | Joël Martin |
| Groovy | Joël Martin |
| Haskell | Joël Martin |
| Haxe (Neko, Python, C++ et JS) | Joël Martin |
| Hy | Joël Martin |
| Io | Dov Murik |
| Jeanne | Sogaiu |
| Java | Joël Martin |
| Truffe Java (Truffe/GraalVM) | Matt McGill |
| JavaScript (démo) | Joël Martin |
| jq | Ali MohammadPur |
| Julie | Joël Martin |
| Kotlin | Javier Fernández-Ivern |
| LaTeX3 | Nicolas Boulenguez |
| LiveScript | Jos van Bakel |
| Logo | Dov Murik |
| Lua | Joël Martin |
| Marque GNU | Joël Martin |
| mal lui-même | Joël Martin |
| MATLAB (GNU Octave et MATLAB) | Joël Martin |
| miniMAL (Repo, Démo) | Joël Martin |
| MSNA | Ben Dudson |
| Nim | Dennis Felsing |
| Objet Pascal | Joël Martin |
| Objectif C | Joël Martin |
| OCaml | Chris Houser |
| Perl | Joël Martin |
| Perl6 | Hinrik Örn Sigurðsson |
| PHP | Joël Martin |
| Picolisp | Vassili Schneidermann |
| Brochet | Dov Murik |
| PL/pgSQL (PostgreSQL) | Joël Martin |
| PL/SQL (Oracle) | Joël Martin |
| PostScript | Joël Martin |
| PowerShell | Joël Martin |
| Prologue | Nicolas Boulenguez |
| PureScript | Mme Kut |
| Python2 | Joël Martin |
| Python3 | Gavin Lewis |
| Python | Joël Martin |
| R. | Joël Martin |
| Raquette | Joël Martin |
| Rexx | Dov Murik |
| Rubis | Joël Martin |
| Rubis #2 | Ryan Cook |
| Rouiller | Joël Martin |
| Échelle | Joël Martin |
| Régime (R7RS) | Vassili Schneidermann |
| Fausser | Dov Murik |
| ML standard | Fabian Bergström |
| Rapide 3 | Joël Martin |
| Rapide 4 | 陆遥 |
| Rapide 6 | Oleg Montak |
| Tcl | Dov Murik |
| Manuscrit | Masahiro Wakamé |
| Vala | Simon Tatham |
| VHDL | Dov Murik |
| Vimscript | Dov Murik |
| Visual Basic.NET | Joël Martin |
| Script Visual Basic | 刘百超 |
| WebAssembly (wasm) | Joël Martin |
| Roitelet | Dov Murik |
| XSLT | Ali MohammadPur |
| Yorick | Dov Murik |
| Zig | Josh Tobin |
Mal a été présenté publiquement pour la première fois lors d'une conférence éclair à Clojure West 2014 (malheureusement, il n'y a pas de vidéo). Voir examples/clojurewest2014.mal pour la présentation qui a été donnée lors de la conférence (oui, la présentation est un programme mal).
Lors de Midwest.io 2015, Joel Martin a fait une présentation sur Mal intitulée « Achievement Unlocked : A Better Path to Language Learning ». Vidéo, diapositives.
Plus récemment, Joel a fait une présentation sur « Créez votre propre interprète Lisp en 10 étapes incrémentielles » à LambdaConf 2016 : partie 1, partie 2, partie 3, partie 4, diapositives.
Le moyen le plus simple d’exécuter une implémentation donnée est d’utiliser Docker. Chaque implémentation dispose d'une image Docker prédéfinie avec les dépendances de langage installées. Vous pouvez lancer le REPL en utilisant une cible pratique dans le Makefile de niveau supérieur (où IMPL est le nom du répertoire d'implémentation et stepX est l'étape à exécuter) :
make DOCKERIZE=1 "repl^IMPL^stepX"
# OR stepA is the default step:
make DOCKERIZE=1 "repl^IMPL"
Les implémentations suivantes sont conservées en tant que projets distincts :
L'implémentation Ada a été développée avec GNAT 4.9 sur Debian. Il compile également sans modification sous Windows si vous disposez des versions Windows de git, GNAT et (éventuellement) make. Il n'y a pas de dépendances externes (readline non implémenté).
cd impls/ada
make
./stepX_YYY
La deuxième implémentation d'Ada a été développée avec GNAT 8 et est liée à la bibliothèque GNU readline.
cd impls/ada
make
./stepX_YYY
L'implémentation GNU awk de mal a été testée avec GNU awk 4.1.1.
cd impls/gawk
gawk -O -f stepX_YYY.awk
cd impls/bash
bash stepX_YYY.sh
L'implémentation BASIC utilise un préprocesseur capable de générer du code BASIC compatible avec C64 BASIC (CBM v2) ou QBasic. Le mode C64 a été testé avec cbmbasic (la version corrigée est actuellement requise pour résoudre les problèmes de saisie de ligne) et le mode QBasic a été testé avec FreeBASIC.
Générez du code C64 et exécutez-le à l'aide de cbmbasic :
cd impls/basic
make MODE=cbm stepX_YYY.bas
STEP=stepX_YYY basic_MODE=cbm ./run
Générez du code QBasic, compilez-le à l'aide de FreeBASIC et exécutez-le :
cd impls/basic
make MODE=qbasic stepX_YYY.bas
make MODE=qbasic stepX_YYY
./stepX_YYY
Merci à Steven Syrek pour l'inspiration originale de cette implémentation.
L'implémentation BBC BASIC V peut s'exécuter dans l'interpréteur Brandy :
cd impls/bbc-basic
brandy -quit stepX_YYY.bbc
Ou sous ARM BBC BASIC V sous RISC OS 3 ou version ultérieure :
*Dir bbc-basic.riscos
*Run setup
*Run stepX_YYY
L'implémentation C de mal nécessite les bibliothèques suivantes (paquets lib et header) : glib, libffi6, libgc et la bibliothèque libedit ou GNU readline.
cd impls/c
make
./stepX_YYY
La deuxième implémentation C de mal nécessite les bibliothèques suivantes (paquets lib et header) : libedit, libgc, libdl et libffi.
cd impls/c.2
make
./stepX_YYY
L'implémentation C++ de mal nécessite g++-4.9 ou clang++-3.5 et une bibliothèque compatible readline pour être construite. Voir cpp/README.md pour plus de détails :
cd impls/cpp
make
# OR
make CXX=clang++-3.5
./stepX_YYY
L'implémentation C# de mal a été testée sur Linux à l'aide du compilateur Mono C# (mcs) et du runtime Mono (version 2.10.8.1). Les deux sont nécessaires pour créer et exécuter l’implémentation C#.
cd impls/cs
make
mono ./stepX_YYY.exe
L'implémentation de ChucK a été testée avec ChucK 1.3.5.2.
cd impls/chuck
./run
Pour la plupart, l'implémentation de Clojure nécessite Clojure 1.5, cependant, pour réussir tous les tests, Clojure 1.8.0-RC4 est requis.
cd impls/clojure
lein with-profile +stepX trampoline run
sudo npm install -g coffee-script
cd impls/coffee
coffee ./stepX_YYY
L'implémentation a été testée avec SBCL, CCL, CMUCL, GNU CLISP, ECL et Allegro CL sur Ubuntu 16.04 et Ubuntu 12.04, voir le README pour plus de détails. À condition que les dépendances mentionnées soient installées, procédez comme suit pour exécuter l'implémentation
cd impls/common-lisp
make
./run
L'implémentation Crystal de mal a été testée avec Crystal 0.26.1.
cd impls/crystal
crystal run ./stepX_YYY.cr
# OR
make # needed to run tests
./stepX_YYY
L'implémentation D de mal a été testée avec GDC 4.8. Cela nécessite la bibliothèque GNU readline.
cd impls/d
make
./stepX_YYY
L'implémentation de Dart a été testée avec Dart 1.20.
cd impls/dart
dart ./stepX_YYY
L'implémentation Emacs Lisp de mal a été testée avec Emacs 24.3 et 24.5. Bien qu'il existe une édition de ligne de lecture très basique ( <backspace> et Cd fonctionnent, Cc annule le processus), il est recommandé d'utiliser rlwrap .
cd impls/elisp
emacs -Q --batch --load stepX_YYY.el
# with full readline support
rlwrap emacs -Q --batch --load stepX_YYY.el
L'implémentation Elixir de mal a été testée avec Elixir 1.0.5.
cd impls/elixir
mix stepX_YYY
# Or with readline/line editing functionality:
iex -S mix stepX_YYY
L'implémentation Elm de mal a été testée avec Elm 0.18.0
cd impls/elm
make stepX_YYY.js
STEP=stepX_YYY ./run
L'implémentation Erlang de mal nécessite Erlang/OTP R17 et des barres d'armature pour être construites.
cd impls/erlang
make
# OR
MAL_STEP=stepX_YYY rebar compile escriptize # build individual step
./stepX_YYY
L'implémentation ES6 / ECMAScript 2015 utilise le compilateur babel pour générer du JavaScript compatible ES5. Le code généré a été testé avec Node 0.12.4.
cd impls/es6
make
node build/stepX_YYY.js
L'implémentation F# de mal a été testée sur Linux à l'aide du compilateur Mono F# (fsharpc) et du runtime Mono (version 3.12.1). Le compilateur mono C# (mcs) est également nécessaire pour compiler la dépendance readline. Tous sont requis pour créer et exécuter l’implémentation F#.
cd impls/fsharp
make
mono ./stepX_YYY.exe
L'implémentation Factor de mal a été testée avec Factor 0.97 (factorcode.org).
cd impls/factor
FACTOR_ROOTS=. factor -run=stepX_YYY
L'implémentation Fantom de mal a été testée avec Fantom 1.0.70.
cd impls/fantom
make lib/fan/stepX_YYY.pod
STEP=stepX_YYY ./run
L'implémentation Fennel de mal a été testée avec Fennel version 0.9.1 sur Lua 5.4.
cd impls/fennel
fennel ./stepX_YYY.fnl
cd impls/forth
gforth stepX_YYY.fs
cd impls/guile
guile -L ./ stepX_YYY.scm
L'implémentation Smalltalk de mal a été testée avec GNU Smalltalk 3.2.91.
cd impls/gnu-smalltalk
./run
L'implémentation Go de mal nécessite que go soit installé sur le chemin. L'implémentation a été testée avec Go 1.3.1.
cd impls/go
make
./stepX_YYY
L'implémentation Groovy de mal nécessite l'exécution de Groovy et a été testée avec Groovy 1.8.6.
cd impls/groovy
make
groovy ./stepX_YYY.groovy
L'implémentation Haskell nécessite le compilateur ghc version 7.10.1 ou ultérieure ainsi que les packages Haskell parsec et readline (ou editline).
cd impls/haskell
make
./stepX_YYY
L'implémentation Haxe de mal nécessite la version Haxe 3.2 pour être compilée. Quatre cibles Haxe différentes sont prises en charge : Neko, Python, C++ et 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
L'implémentation Hy de mal a été testée avec Hy 0.13.0.
cd impls/hy
./stepX_YYY.hy
L'implémentation Io de mal a été testée avec la version Io 20110905.
cd impls/io
io ./stepX_YYY.io
L'implémentation Janet de mal a été testée avec Janet version 1.12.2.
cd impls/janet
janet ./stepX_YYY.janet
L'implémentation Java de mal nécessite la construction de 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"
Cette implémentation Java fonctionnera sur OpenJDK, mais peut s'exécuter jusqu'à 30 fois plus rapidement sur GraalVM grâce au framework Truffle. Il a été testé avec OpenJDK 11, GraalVM CE 20.1.0 et GraalVM CE 21.1.0.
cd impls/java-truffle
./gradlew build
STEP=stepX_YYY ./run
cd impls/js
npm install
node stepX_YYY.js
L'implémentation Julia de mal nécessite Julia 0.4.
cd impls/julia
julia stepX_YYY.jl
Testé avec la version 1.6, avec beaucoup de tricherie dans le département IO
cd impls/jq
STEP=stepA_YYY ./run
# with Debug
DEBUG=true STEP=stepA_YYY ./run
L'implémentation Kotlin de mal a été testée avec Kotlin 1.0.
cd impls/kotlin
make
java -jar stepX_YYY.jar
L'implémentation LaTeX3 de mal a été testée avec pdfTeX 3.141592653-2.6-1.40.24.
L'auto-hébergement est trop lent pour un délai d'attente raisonnable et plante à l'étape 4, apparemment en raison de limitations codées en dur.
Toute personne travaillant là-dessus doit décommenter les deux lignes d'options de débogage (lentes) dans le fichier step et exporter DEBUG=1 (pour plus de résultats que ce que les tests acceptent).
L'implémentation LiveScript de mal a été testée avec LiveScript 1.5.
cd impls/livescript
make
node_modules/.bin/lsc stepX_YYY.ls
L'implémentation Logo de mal a été testée avec UCBLogo 6.0.
cd impls/logo
logo stepX_YYY.lg
L'implémentation Lua de mal a été testée avec Lua 5.3.5. L'implémentation nécessite l'installation de Luarocks.
cd impls/lua
make # to build and link linenoise.so and rex_pcre.so
./stepX_YYY.lua
L'exécution de l'implémentation mal de mal implique l'exécution de l'étape A de l'une des autres implémentations et la transmission de l'étape mal pour qu'elle s'exécute en tant qu'argument de ligne de commande.
cd impls/IMPL
IMPL_STEPA_CMD ../mal/stepX_YYY.mal
cd impls/make
make -f stepX_YYY.mk
L'implémentation NASM de mal est écrite pour Linux x86-64 et a été testée avec Linux 3.16.0-4-amd64 et NASM version 2.11.05.
cd impls/nasm
make
./stepX_YYY
L'implémentation Nim de mal a été testée avec Nim 1.0.4.
cd impls/nim
make
# OR
nimble build
./stepX_YYY
L'implémentation Object Pascal de mal a été construite et testée sous Linux à l'aide du compilateur Free Pascal versions 2.6.2 et 2.6.4.
cd impls/objpascal
make
./stepX_YYY
L'implémentation Objective C de mal a été construite et testée sur Linux en utilisant clang/LLVM 3.6. Il a également été construit et testé sur OS X en utilisant Xcode 7.
cd impls/objc
make
./stepX_YYY
cd impls/ocaml
make
./stepX_YYY
L'implémentation MatLab a été testée avec GNU Octave 4.2.1. Il a également été testé avec MATLAB version R2014a sous Linux. Notez que MATLAB est un produit commercial.
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 est un petit interpréteur Lisp implémenté en moins de 1024 octets de JavaScript. Pour exécuter l'implémentation miniMAL de mal, vous devez télécharger/installer l'interpréteur miniMAL (qui nécessite Node.js).
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
L'implémentation de Perl 5 devrait fonctionner avec Perl 5.19.3 et versions ultérieures.
Pour la prise en charge de l'édition de ligne readline, installez Term::ReadLine::Perl ou Term::ReadLine::Gnu à partir de CPAN.
cd impls/perl
perl stepX_YYY.pl
L'implémentation de Perl 6 a été testée sur Rakudo Perl 6 2016.04.
cd impls/perl6
perl6 stepX_YYY.pl
L'implémentation PHP de mal nécessite l'exécution de l'interface de ligne de commande php.
cd impls/php
php stepX_YYY.php
L'implémentation de Picolisp nécessite libreadline et Picolisp 3.1.11 ou version ultérieure.
cd impls/picolisp
./run
L'implémentation de Pike a été testée sur Pike 8.0.
cd impls/pike
pike stepX_YYY.pike
L'implémentation PL/pgSQL de mal nécessite un serveur PostgreSQL en cours d'exécution (l'image docker "kanaka/mal-test-plpgsql" démarre automatiquement un serveur PostgreSQL). L'implémentation se connecte au serveur PostgreSQL et crée une base de données nommée "mal" pour stocker les tables et les procédures stockées. Le script wrapper utilise la commande psql pour se connecter au serveur et utilise par défaut l'utilisateur "postgres", mais cela peut être remplacé par la variable d'environnement PSQL_USER. Un mot de passe peut être spécifié à l'aide de la variable d'environnement PGPASSWORD. L'implémentation a été testée avec PostgreSQL 9.4.
cd impls/plpgsql
./wrap.sh stepX_YYY.sql
# OR
PSQL_USER=myuser PGPASSWORD=mypass ./wrap.sh stepX_YYY.sql
L'implémentation PL/SQL de mal nécessite un serveur Oracle DB en cours d'exécution (l'image docker "kanaka/mal-test-plsql" démarre automatiquement un serveur Oracle Express). L'implémentation se connecte au serveur Oracle pour créer des types, des tables et des procédures stockées. La valeur de connexion SQL*Plus par défaut (nom d'utilisateur/mot de passe@connect_identifier) est "system/oracle", mais elle peut être remplacée par la variable d'environnement ORACLE_LOGON. L'implémentation a été testée avec Oracle Express Edition 11g Release 2. Notez que tout avertissement de connexion SQL*Plus (expiration du mot de passe utilisateur, etc.) interférera avec la capacité du script wrapper à communiquer avec la base de données.
cd impls/plsql
./wrap.sh stepX_YYY.sql
# OR
ORACLE_LOGON=myuser/mypass@ORCL ./wrap.sh stepX_YYY.sql
L'implémentation PostScript de mal nécessite l'exécution de Ghostscript. Il a été testé avec Ghostscript 9.10.
cd impls/ps
gs -q -dNODISPLAY -I./ stepX_YYY.ps
L'implémentation PowerShell de mal nécessite le langage de script PowerShell. Il a été testé avec PowerShell 6.0.0 Alpha 9 sous Linux.
cd impls/powershell
powershell ./stepX_YYY.ps1
L'implémentation de Prolog utilise certaines constructions spécifiques à SWI-Prolog, inclut le support readline et a été testée sur Debian GNU/Linux avec la version 8.2.1.
cd impls/prolog
swipl stepX_YYY
L'implémentation PureScript nécessite la version 0.20.2 du compilateur spago.
cd impls/purs
make
node ./stepX_YYY.js
Cette implémentation utilise uniquement les fonctionnalités de python2, mais évite les incompatibilités avec python3.
Cette implémentation est vérifiée pour le style et les types (flake8, pylint, mypy). Il rapporte toutes les erreurs avec des détails. Il démontre les itérateurs, les décorateurs, les outils fonctionnels, les cartes de chaîne, les classes de données, l'introspection, les instructions de correspondance, les expressions d'affectation.
Vous devez avoir rpython sur votre chemin (inclus avec pypy).
cd impls/rpython
make # this takes a very long time
./stepX_YYY
L'implémentation R de mal nécessite l'exécution de R (r-base-core).
cd impls/r
make libs # to download and build rdyncall
Rscript stepX_YYY.r
L'implémentation Racket de mal nécessite l'exécution du compilateur/interpréteur Racket.
cd impls/racket
./stepX_YYY.rkt
L'implémentation Rexx de mal a été testée avec Regina Rexx 3.6.
cd impls/rexx
make
rexx -a ./stepX_YYY.rexxpp
cd impls/ruby
ruby stepX_YYY.rb
Une deuxième implémentation Ruby avec les objectifs suivants :
Mal cd impls/ruby.2
ruby stepX_YYY.rb
L'implémentation rust de mal nécessite le compilateur rust et l'outil de construction (cargo) pour être construit.
cd impls/rust
cargo run --release --bin stepX_YYY
Installez scala et 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
L'implémentation Scheme de MAL a été testée avec Chibi-Scheme 0.10, Kawa 3.1.1, Gauche 0.9.6, CHICKEN 5.1.0, Sagittarius 0.9.7, Cyclone 0.32.0 (version Git) et Foment 0.4 (version Git). Vous devriez pouvoir le faire fonctionner sur d'autres implémentations R7RS conformes après avoir compris comment les bibliothèques sont chargées et ajusté le Makefile et run le script en conséquence.
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
L'implémentation Skew de mal a été testée avec Skew 0.7.42.
cd impls/skew
make
node stepX_YYY.js
L'implémentation Standard ML de mal nécessite une implémentation SML97. Le Makefile prend en charge Poly/ML, MLton, Moscou ML et a été testé avec Poly/ML 5.8.1, MLton 20210117 et Moscou ML version 2.10.
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
L'implémentation Swift 3 de mal nécessite le compilateur Swift 3.0. Il a été testé avec Swift 3 Preview 3.
cd impls/swift3
make
./stepX_YYY
L'implémentation Swift 4 de mal nécessite le compilateur Swift 4.0. Il a été testé avec la version Swift 4.2.3.
cd impls/swift4
make
./stepX_YYY
L'implémentation Swift 5 de mal nécessite le compilateur Swift 5.0. Il a été testé avec la version Swift 5.1.1.
cd impls/swift6
swift run stepX_YYY
L'implémentation Tcl de mal nécessite l'exécution de Tcl 8.6. Pour la prise en charge de l’édition de ligne readline, installez tclreadline.
cd impls/tcl
tclsh ./stepX_YYY.tcl
L'implémentation TypeScript de mal nécessite le compilateur TypeScript 2.2. Il a été testé avec Node.js v6.
cd impls/ts
make
node ./stepX_YYY.js
L'implémentation Vala de mal a été testée avec le compilateur Vala 0.40.8. Vous devrez installer valac et libreadline-dev ou équivalent.
cd impls/vala
make
./stepX_YYY
L'implémentation VHDL de mal a été testée avec GHDL 0.29.
cd impls/vhdl
make
./run_vhdl.sh ./stepX_YYY
L'implémentation Vimscript de mal nécessite l'exécution de Vim 8.0.
cd impls/vimscript
./run_vimscript.sh ./stepX_YYY.vim
L'implémentation VB.NET de mal a été testée sous Linux à l'aide du compilateur Mono VB (vbnc) et du runtime Mono (version 2.10.8.1). Les deux sont nécessaires pour créer et exécuter l’implémentation de VB.NET.
cd impls/vb
make
mono ./stepX_YYY.exe
L'implémentation VBScript de mal a été testée sur Windows 10 1909. install.vbs peut vous aider à installer la configuration requise (.NET 2.0 3.0 3.5). Si vous n'avez pas installé .NET 2.0 3.0 3.5 , une fenêtre apparaîtra pour l'installation. Si vous l'avez déjà installé, cela ne fera rien.
cd implsvbs
install.vbs
cscript -nologo stepX_YYY.vbs
L'implémentation de WebAssembly est écrite en Wam (langage WebAssembly Macro) et s'exécute sous plusieurs intégrations (runtimes) non Web différentes : 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
L'implémentation XSLT de mal est écrite avec XSLT 3 et testée sur Saxon 9.9.1.6 Home Edition.
cd impls/xslt
STEP=stepX_YY ./run
L'implémentation Wren de mal a été testée sur Wren 0.2.0.
cd impls/wren
wren ./stepX_YYY.wren
L'implémentation Yorick de mal a été testée sur Yorick 2.2.04.
cd impls/yorick
yorick -batch ./stepX_YYY.i
L'implémentation Zig de mal a été testée sur Zig 0.5.
cd impls/zig
zig build stepX_YYY
Le Makefile de niveau supérieur comporte un certain nombre de cibles utiles pour faciliter le développement et les tests de l'implémentation. La cible help fournit une liste des cibles et des options :
make help
Il y a près de 800 tests fonctionnels génériques (pour toutes les implémentations) dans le répertoire tests/ . Chaque étape possède un fichier de test correspondant contenant des tests spécifiques à cette étape. Le harnais de test runtest.py lance une implémentation d'étape Mal, puis transmet les tests un par un à l'implémentation et compare la valeur de sortie/retour à la valeur de sortie/retour attendue.
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 comme implémentation de test et utilisez la variable make MAL_IMPL pour modifier le langage hôte sous-jacent (la valeur par défaut est 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 est utilisée : make "repl^IMPL"
# e.g
make "repl^ruby"
make "repl^ps"
mal comme implémentation REPL et utilisez la variable make MAL_IMPL pour modifier le langage hôte sous-jacent (la valeur par défaut est 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"
Avertissement : Ces tests de performances ne sont ni statistiquement valides ni exhaustifs ; les performances d'exécution ne sont pas un objectif principal de mal. Si vous tirez des conclusions sérieuses de ces tests de performance, contactez-moi au sujet d'une superbe propriété en bord de mer au Kansas que je suis prêt à vous vendre à bas prix.
make "perf^IMPL"
# e.g.
make "perf^js"
make "perf"
make "stats^IMPL"
# e.g.
make "stats^js"
Chaque répertoire d'implémentation contient un Dockerfile pour créer une image Docker contenant toutes les dépendances de cette implémentation. De plus, le Makefile de niveau supérieur prend en charge l'exécution de la cible des tests (et les performances, les statistiques, le repl, etc.) dans un conteneur Docker pour cette implémentation en passant "DOCKERIZE=1" sur la ligne de commande make. Par exemple:
make DOCKERIZE=1 "test^js^step3"
Les implémentations existantes ont déjà des images Docker créées et transférées vers le registre Docker. Cependant, si vous souhaitez créer ou reconstruire une image Docker localement, le Makefile de niveau supérieur fournit une règle pour créer des images Docker :
make "docker-build^IMPL"
Remarques :
make DOCKERIZE=1 "repl^IMPL" avant de pouvoir exécuter des tests car les dépendances d'exécution doivent être téléchargées pour éviter le les tests expirent. Ces dépendances sont téléchargées dans des fichiers point dans le répertoire /mal afin qu'elles persistent entre les exécutions. Mal (make-a-lisp) est sous licence MPL 2.0 (Mozilla Public License 2.0). Voir LICENSE.txt pour plus de détails.
