mal
1.0.0
1. Mal es un intérprete de Lisp inspirado en Clojure
2. Mal es una herramienta de aprendizaje
Cada implementación de mal se divide en 11 pasos incrementales, autónomos (y comprobables) que demuestran los conceptos básicos de Lisp. El último paso es capaz de autohospedarse (ejecutar la implementación mal de mal). Consulte la guía del proceso make-a-lisp.
Los pasos para hacer un ceceo son:
Cada paso de make-a-lisp tiene un diagrama arquitectónico asociado. Que los elementos que son nuevos para ese paso estén resaltados en rojo. Aquí está la arquitectura final una vez que se completa el paso A:
Si está interesado en crear una implementación de mal (o simplemente está interesado en usar mal para algo), puede unirse a nuestro Discord. Además de la guía del proceso make-a-lisp, también hay preguntas frecuentes sobre mal/make-a-lisp donde intento responder algunas preguntas comunes.
3. Mal está implementado en 88 idiomas (94 implementaciones diferentes y 117 modos de ejecución)
| Idioma | Creador |
|---|---|
| ada | Chris Moore |
| ada #2 | Nicolás Boulenguez |
| GNU Awk | Mitsuru Kariya |
| Golpe 4 | Joel Martín |
| BÁSICO (C64 y QBásico) | Joel Martín |
| BBC BÁSICO V | ben harris |
| do | Joel Martín |
| C#2 | Duncan Watts |
| C++ | Esteban Thirlwall |
| DO# | Joel Martín |
| Arrojar | Vasilij Schneidermann |
| Clojure (Clojure y ClojureScript) | Joel Martín |
| CaféScript | Joel Martín |
| ceceo común | Iqbal Ansari |
| Cristal | linda_pp |
| D | Dov Murik |
| Dardo | Harry Terkelsen |
| Elixir | martin ek |
| Olmo | José van Bakel |
| Emacs Lisp | Vasilij Schneidermann |
| erlang | Nathan Fiedler |
| ES6 (ECMAScript 2015) | Joel Martín |
| F# | Peter Esteban |
| Factor | Jordán Lewis |
| fantasma | Dov Murik |
| Hinojo | sogaiu |
| Adelante | Chris Houser |
| GNU astucia | Mu Lei |
| Charla pequeña de GNU | Vasilij Schneidermann |
| Ir | Joel Martín |
| maravilloso | Joel Martín |
| Haskell | Joel Martín |
| Haxe (Neko, Python, C++ y JS) | Joel Martín |
| hola | Joel Martín |
| yo | Dov Murik |
| janet | sogaiu |
| Java | Joel Martín |
| Trufa de Java (Truffle/GraalVM) | Matt McGill |
| JavaScript (demostración) | Joel Martín |
| jq | Ali Mohammad Pur |
| Julia | Joel Martín |
| Kotlin | Javier Fernández-Ivern |
| Látex3 | Nicolás Boulenguez |
| LiveScript | José van Bakel |
| Logo | Dov Murik |
| lua | Joel Martín |
| Marca GNU | Joel Martín |
| mal mismo | Joel Martín |
| MATLAB (GNU Octava y MATLAB) | Joel Martín |
| miniMAL (repositorio, demostración) | Joel Martín |
| NASM | Ben Dudson |
| nim | Dennis Felsing |
| Objeto Pascal | Joel Martín |
| Objetivo C | Joel Martín |
| OCaml | Chris Houser |
| perla | Joel Martín |
| Perla 6 | Hinrik Örn Sigurðsson |
| PHP | Joel Martín |
| Picolisp | Vasilij Schneidermann |
| Lucio | Dov Murik |
| PL/pgSQL (PostgreSQL) | Joel Martín |
| PL/SQL (Oracle) | Joel Martín |
| Posdata | Joel Martín |
| PowerShell | Joel Martín |
| Prólogo | Nicolás Boulenguez |
| Puro script | mrsekut |
| Python2 | Joel Martín |
| Python3 | Gavin Lewis |
| RPython | Joel Martín |
| R | Joel Martín |
| Raqueta | Joel Martín |
| Rexx | Dov Murik |
| Rubí | Joel Martín |
| rubí #2 | ryan cocinar |
| Óxido | Joel Martín |
| escala | Joel Martín |
| Esquema (R7RS) | Vasilij Schneidermann |
| Sesgar | Dov Murik |
| AA estándar | Fabián Bergström |
| veloz 3 | Joel Martín |
| veloz 4 | 陆遥 |
| veloz 6 | Oleg Montak |
| tcl | Dov Murik |
| Mecanografiado | Masahiro Wakame |
| vala | Simón Tatham |
| VHDL | Dov Murik |
| vimscript | Dov Murik |
| Visual Basic.NET | Joel Martín |
| Guión visual básico | 刘百超 |
| Asamblea web (wasm) | Joel Martín |
| Reyezuelo | Dov Murik |
| XSLT | Ali Mohammad Pur |
| Yorick | Dov Murik |
| Zig | jose tobin |
Mal fue presentado públicamente por primera vez en una charla relámpago en Clojure West 2014 (lamentablemente no hay vídeo). Consulte ejemplos/clojurewest2014.mal para ver la presentación que se realizó en la conferencia (sí, la presentación es un programa mal).
En Midwest.io 2015, Joel Martin hizo una presentación sobre Mal titulada "Logros desbloqueados: un mejor camino hacia el aprendizaje de idiomas". Vídeo, diapositivas.
Más recientemente, Joel hizo una presentación sobre "Crea tu propio intérprete Lisp en 10 pasos incrementales" en LambdaConf 2016: Parte 1, Parte 2, Parte 3, Parte 4, Diapositivas.
La forma más sencilla de ejecutar cualquier implementación determinada es utilizar Docker. Cada implementación tiene una imagen de Docker prediseñada con dependencias de idioma instaladas. Puede iniciar REPL utilizando un destino conveniente en el Makefile de nivel superior (donde IMPL es el nombre del directorio de implementación y stepX es el paso a ejecutar):
make DOCKERIZE=1 "repl^IMPL^stepX"
# OR stepA is the default step:
make DOCKERIZE=1 "repl^IMPL"
Las siguientes implementaciones se mantienen como proyectos separados:
La implementación de Ada se desarrolló con GNAT 4.9 en Debian. También se compila sin cambios en Windows si tiene versiones de Windows de git, GNAT y (opcionalmente) make. No hay dependencias externas (readline no implementada).
cd impls/ada
make
./stepX_YYY
La segunda implementación de Ada se desarrolló con GNAT 8 y se vincula con la biblioteca readline de GNU.
cd impls/ada
make
./stepX_YYY
La implementación GNU awk de mal se ha probado con GNU awk 4.1.1.
cd impls/gawk
gawk -O -f stepX_YYY.awk
cd impls/bash
bash stepX_YYY.sh
La implementación BASIC utiliza un preprocesador que puede generar código BASIC que es compatible tanto con C64 BASIC (CBM v2) como con QBasic. El modo C64 se probó con cbmbasic (actualmente se requiere la versión parcheada para solucionar problemas con la entrada de línea) y el modo QBasic se probó con FreeBASIC.
Genere código C64 y ejecútelo usando cbmbasic:
cd impls/basic
make MODE=cbm stepX_YYY.bas
STEP=stepX_YYY basic_MODE=cbm ./run
Genere código QBasic, compílelo usando FreeBASIC y ejecútelo:
cd impls/basic
make MODE=qbasic stepX_YYY.bas
make MODE=qbasic stepX_YYY
./stepX_YYY
Gracias a Steven Syrek por la inspiración original para esta implementación.
La implementación de BBC BASIC V se puede ejecutar en el intérprete de Brandy:
cd impls/bbc-basic
brandy -quit stepX_YYY.bbc
O en ARM BBC BASIC V bajo RISC OS 3 o posterior:
*Dir bbc-basic.riscos
*Run setup
*Run stepX_YYY
La implementación C de mal requiere las siguientes bibliotecas (paquetes lib y de encabezado): glib, libffi6, libgc y la biblioteca libedit o GNU readline.
cd impls/c
make
./stepX_YYY
La segunda implementación C de mal requiere las siguientes bibliotecas (paquetes lib y de encabezado): libedit, libgc, libdl y libffi.
cd impls/c.2
make
./stepX_YYY
La implementación C++ de mal requiere g++-4.9 o clang++-3.5 y una biblioteca compatible con readline para su compilación. Consulte cpp/README.md para obtener más detalles:
cd impls/cpp
make
# OR
make CXX=clang++-3.5
./stepX_YYY
La implementación de mal en C# se ha probado en Linux utilizando el compilador Mono C# (mcs) y el tiempo de ejecución Mono (versión 2.10.8.1). Ambos son necesarios para compilar y ejecutar la implementación de C#.
cd impls/cs
make
mono ./stepX_YYY.exe
La implementación de ChucK ha sido probada con ChucK 1.3.5.2.
cd impls/chuck
./run
En su mayor parte, la implementación de Clojure requiere Clojure 1.5; sin embargo, para pasar todas las pruebas, se requiere Clojure 1.8.0-RC4.
cd impls/clojure
lein with-profile +stepX trampoline run
sudo npm install -g coffee-script
cd impls/coffee
coffee ./stepX_YYY
La implementación se ha probado con SBCL, CCL, CMUCL, GNU CLISP, ECL y Allegro CL en Ubuntu 16.04 y Ubuntu 12.04; consulte el archivo README para obtener más detalles. Siempre que tenga instaladas las dependencias mencionadas, haga lo siguiente para ejecutar la implementación
cd impls/common-lisp
make
./run
La implementación Crystal de mal se ha probado con Crystal 0.26.1.
cd impls/crystal
crystal run ./stepX_YYY.cr
# OR
make # needed to run tests
./stepX_YYY
La implementación D de mal se probó con GDC 4.8. Requiere la biblioteca GNU readline.
cd impls/d
make
./stepX_YYY
La implementación de Dart se ha probado con Dart 1.20.
cd impls/dart
dart ./stepX_YYY
La implementación de mal en Emacs Lisp se ha probado con Emacs 24.3 y 24.5. Si bien existe una edición de línea de lectura muy básica ( <backspace> y Cd funcionan, Cc cancela el proceso), se recomienda usar rlwrap .
cd impls/elisp
emacs -Q --batch --load stepX_YYY.el
# with full readline support
rlwrap emacs -Q --batch --load stepX_YYY.el
La implementación de mal en Elixir ha sido probada con Elixir 1.0.5.
cd impls/elixir
mix stepX_YYY
# Or with readline/line editing functionality:
iex -S mix stepX_YYY
La implementación de mal en Elm se ha probado con Elm 0.18.0
cd impls/elm
make stepX_YYY.js
STEP=stepX_YYY ./run
La implementación de mal en Erlang requiere Erlang/OTP R17 y barras de refuerzo para construir.
cd impls/erlang
make
# OR
MAL_STEP=stepX_YYY rebar compile escriptize # build individual step
./stepX_YYY
La implementación de ES6/ECMAScript 2015 utiliza el compilador babel para generar JavaScript compatible con ES5. El código generado ha sido probado con el Nodo 0.12.4.
cd impls/es6
make
node build/stepX_YYY.js
La implementación de mal en F# se ha probado en Linux utilizando el compilador Mono F# (fsharpc) y el tiempo de ejecución Mono (versión 3.12.1). El compilador mono C# (mcs) también es necesario para compilar la dependencia readline. Todos son necesarios para compilar y ejecutar la implementación de F#.
cd impls/fsharp
make
mono ./stepX_YYY.exe
La implementación del factor mal ha sido probada con el factor 0.97 (factorcode.org).
cd impls/factor
FACTOR_ROOTS=. factor -run=stepX_YYY
La implementación Fantom de mal se ha probado con Fantom 1.0.70.
cd impls/fantom
make lib/fan/stepX_YYY.pod
STEP=stepX_YYY ./run
La implementación de mal en Fennel se ha probado con la versión 0.9.1 de Fennel en 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
La implementación de mal en Smalltalk se ha probado con GNU Smalltalk 3.2.91.
cd impls/gnu-smalltalk
./run
La implementación Go de mal requiere que go esté instalado en la ruta. La implementación ha sido probada con Go 1.3.1.
cd impls/go
make
./stepX_YYY
La implementación de mal en Groovy requiere que Groovy se ejecute y ha sido probada con Groovy 1.8.6.
cd impls/groovy
make
groovy ./stepX_YYY.groovy
La implementación de Haskell requiere la versión 7.10.1 o posterior del compilador ghc y también los paquetes Haskell parsec y readline (o editline).
cd impls/haskell
make
./stepX_YYY
La implementación de mal en Haxe requiere la versión 3.2 de Haxe para compilarse. Se admiten cuatro objetivos Haxe diferentes: Neko, Python, C++ y 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
La implementación Hy de mal se ha probado con Hy 0.13.0.
cd impls/hy
./stepX_YYY.hy
La implementación de Io de mal se ha probado con la versión 20110905 de Io.
cd impls/io
io ./stepX_YYY.io
La implementación de mal de Janet se ha probado con la versión 1.12.2 de Janet.
cd impls/janet
janet ./stepX_YYY.janet
La implementación Java de mal requiere maven2 para su compilación.
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"
Esta implementación de Java se ejecutará en OpenJDK, pero puede ejecutarse hasta 30 veces más rápido en GraalVM gracias al marco Truffle. Se ha probado con OpenJDK 11, GraalVM CE 20.1.0 y GraalVM CE 21.1.0.
cd impls/java-truffle
./gradlew build
STEP=stepX_YYY ./run
cd impls/js
npm install
node stepX_YYY.js
La implementación de mal en Julia requiere Julia 0.4.
cd impls/julia
julia stepX_YYY.jl
Probado con la versión 1.6, con muchas trampas en el departamento de IO
cd impls/jq
STEP=stepA_YYY ./run
# with Debug
DEBUG=true STEP=stepA_YYY ./run
La implementación de mal en Kotlin se ha probado con Kotlin 1.0.
cd impls/kotlin
make
java -jar stepX_YYY.jar
La implementación LaTeX3 de mal ha sido probada con pdfTeX 3.141592653-2.6-1.40.24.
El autohospedaje es demasiado lento para un tiempo de espera razonable y falla en el paso 4, aparentemente debido a limitaciones codificadas.
Cualquiera que trabaje en esto debería descomentar las dos líneas de opciones de depuración (lenta) en el archivo de pasos y exportar DEBUG=1 (para obtener más resultados de los que aceptan las pruebas).
La implementación de mal en LiveScript se ha probado con LiveScript 1.5.
cd impls/livescript
make
node_modules/.bin/lsc stepX_YYY.ls
La implementación del Logo de mal ha sido probada con UCBLogo 6.0.
cd impls/logo
logo stepX_YYY.lg
La implementación Lua de mal ha sido probada con Lua 5.3.5. La implementación requiere la instalación de luarocks.
cd impls/lua
make # to build and link linenoise.so and rex_pcre.so
./stepX_YYY.lua
Ejecutar la implementación mal de mal implica ejecutar el paso A de una de las otras implementaciones y pasar el paso mal para ejecutarlo como argumento de línea de comando.
cd impls/IMPL
IMPL_STEPA_CMD ../mal/stepX_YYY.mal
cd impls/make
make -f stepX_YYY.mk
La implementación NASM de mal está escrita para Linux x86-64 y ha sido probada con Linux 3.16.0-4-amd64 y NASM versión 2.11.05.
cd impls/nasm
make
./stepX_YYY
La implementación de mal en Nim se ha probado con Nim 1.0.4.
cd impls/nim
make
# OR
nimble build
./stepX_YYY
La implementación de mal de Object Pascal se ha creado y probado en Linux utilizando el compilador Free Pascal versión 2.6.2 y 2.6.4.
cd impls/objpascal
make
./stepX_YYY
La implementación de Objective C de mal se ha creado y probado en Linux utilizando clang/LLVM 3.6. También se ha creado y probado en OS X utilizando Xcode 7.
cd impls/objc
make
./stepX_YYY
cd impls/ocaml
make
./stepX_YYY
La implementación de MatLab ha sido probada con GNU Octave 4.2.1. También ha sido probado con MATLAB versión R2014a en Linux. Tenga en cuenta que MATLAB es un producto comercial.
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 es un pequeño intérprete Lisp implementado en menos de 1024 bytes de JavaScript. Para ejecutar la implementación miniMAL de mal, necesita descargar/instalar el intérprete miniMAL (que requiere 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
La implementación de Perl 5 debería funcionar con Perl 5.19.3 y posteriores.
Para compatibilidad con la edición de líneas readline, instale Term::ReadLine::Perl o Term::ReadLine::Gnu desde CPAN.
cd impls/perl
perl stepX_YYY.pl
La implementación de Perl 6 se probó en Rakudo Perl 6 2016.04.
cd impls/perl6
perl6 stepX_YYY.pl
La implementación PHP de mal requiere que se ejecute la interfaz de línea de comando php.
cd impls/php
php stepX_YYY.php
La implementación de Picolisp requiere libreadline y Picolisp 3.1.11 o posterior.
cd impls/picolisp
./run
La implementación de Pike se probó en Pike 8.0.
cd impls/pike
pike stepX_YYY.pike
La implementación PL/pgSQL de mal requiere un servidor PostgreSQL en ejecución (la imagen acoplable "kanaka/mal-test-plpgsql" inicia automáticamente un servidor PostgreSQL). La implementación se conecta al servidor PostgreSQL y crea una base de datos llamada "mal" para almacenar tablas y procedimientos almacenados. El script contenedor utiliza el comando psql para conectarse al servidor y el usuario predeterminado es "postgres", pero esto se puede anular con la variable de entorno PSQL_USER. Se puede especificar una contraseña utilizando la variable de entorno PGPASSWORD. La implementación ha sido probada con PostgreSQL 9.4.
cd impls/plpgsql
./wrap.sh stepX_YYY.sql
# OR
PSQL_USER=myuser PGPASSWORD=mypass ./wrap.sh stepX_YYY.sql
La implementación PL/SQL de mal requiere un servidor Oracle DB en ejecución (la imagen acoplable "kanaka/mal-test-plsql" inicia automáticamente un servidor Oracle Express). La implementación se conecta al servidor Oracle para crear tipos, tablas y procedimientos almacenados. El valor de inicio de sesión predeterminado de SQL*Plus (nombre de usuario/contraseña@connect_identifier) es "sistema/oracle", pero se puede anular con la variable de entorno ORACLE_LOGON. La implementación se ha probado con Oracle Express Edition 11g Versión 2. Tenga en cuenta que cualquier advertencia de conexión SQL*Plus (caducidad de la contraseña del usuario, etc.) interferirá con la capacidad del script contenedor para comunicarse con la base de datos.
cd impls/plsql
./wrap.sh stepX_YYY.sql
# OR
ORACLE_LOGON=myuser/mypass@ORCL ./wrap.sh stepX_YYY.sql
La implementación PostScript de mal requiere la ejecución de Ghostscript. Ha sido probado con Ghostscript 9.10.
cd impls/ps
gs -q -dNODISPLAY -I./ stepX_YYY.ps
La implementación de PowerShell de mal requiere el lenguaje de script de PowerShell. Ha sido probado con PowerShell 6.0.0 Alpha 9 en Linux.
cd impls/powershell
powershell ./stepX_YYY.ps1
La implementación de Prolog utiliza algunas construcciones específicas de SWI-Prolog, incluye soporte de línea de lectura y ha sido probada en Debian GNU/Linux con la versión 8.2.1.
cd impls/prolog
swipl stepX_YYY
La implementación de PureScript requiere la versión 0.20.2 del compilador spago.
cd impls/purs
make
node ./stepX_YYY.js
Esta implementación solo utiliza funciones de python2, pero evita incompatibilidades con python3.
Esta implementación se verifica en cuanto a estilo y tipos (flake8, pylint, mypy). Informa todos los errores con detalles. Demuestra iteradores, decoradores, herramientas funcionales, mapas de cadena, clases de datos, introspección, declaraciones de coincidencia y expresiones de asignación.
Debes tener rpython en tu ruta (incluido con pypy).
cd impls/rpython
make # this takes a very long time
./stepX_YYY
La implementación R de mal requiere R (r-base-core) para ejecutarse.
cd impls/r
make libs # to download and build rdyncall
Rscript stepX_YYY.r
La implementación de mal en Racket requiere que se ejecute el compilador/intérprete de Racket.
cd impls/racket
./stepX_YYY.rkt
La implementación de mal en Rexx se ha probado con Regina Rexx 3.6.
cd impls/rexx
make
rexx -a ./stepX_YYY.rexxpp
cd impls/ruby
ruby stepX_YYY.rb
Una segunda implementación de Ruby con los siguientes objetivos:
Mal cd impls/ruby.2
ruby stepX_YYY.rb
La implementación de mal en Rust requiere el compilador Rust y la herramienta de compilación (carga) para compilar.
cd impls/rust
cargo run --release --bin stepX_YYY
Instale Scala y 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
La implementación del esquema de MAL ha sido probada con Chibi-Scheme 0.10, Kawa 3.1.1, Gauche 0.9.6, CHICKEN 5.1.0, Sagittarius 0.9.7, Cyclone 0.32.0 (versión Git) y Foment 0.4 (versión Git). Debería poder ejecutarlo en otras implementaciones R7RS compatibles después de descubrir cómo se cargan las bibliotecas y ajustar el Makefile y run el script en consecuencia.
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
La implementación Skew de mal se ha probado con Skew 0.7.42.
cd impls/skew
make
node stepX_YYY.js
La implementación estándar de ML de mal requiere una implementación SML97. Makefile es compatible con Poly/ML, MLton, Moscú ML y ha sido probado con Poly/ML 5.8.1, MLton 20210117 y Moscú ML versión 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
La implementación de mal en Swift 3 requiere el compilador Swift 3.0. Ha sido probado con Swift 3 Preview 3.
cd impls/swift3
make
./stepX_YYY
La implementación de mal en Swift 4 requiere el compilador Swift 4.0. Ha sido probado con la versión Swift 4.2.3.
cd impls/swift4
make
./stepX_YYY
La implementación de mal en Swift 5 requiere el compilador Swift 5.0. Ha sido probado con la versión Swift 5.1.1.
cd impls/swift6
swift run stepX_YYY
La implementación Tcl de mal requiere Tcl 8.6 para ejecutarse. Para admitir la edición de líneas readline, instale tclreadline.
cd impls/tcl
tclsh ./stepX_YYY.tcl
La implementación TypeScript de mal requiere el compilador TypeScript 2.2. Ha sido probado con Node.js v6.
cd impls/ts
make
node ./stepX_YYY.js
La implementación de mal en Vala se ha probado con el compilador Vala 0.40.8. Necesitará instalar valac y libreadline-dev o equivalente.
cd impls/vala
make
./stepX_YYY
La implementación VHDL de mal ha sido probada con GHDL 0.29.
cd impls/vhdl
make
./run_vhdl.sh ./stepX_YYY
La implementación de Vimscript de mal requiere Vim 8.0 para ejecutarse.
cd impls/vimscript
./run_vimscript.sh ./stepX_YYY.vim
La implementación VB.NET de mal se ha probado en Linux utilizando el compilador Mono VB (vbnc) y el tiempo de ejecución Mono (versión 2.10.8.1). Ambos son necesarios para construir y ejecutar la implementación de VB.NET.
cd impls/vb
make
mono ./stepX_YYY.exe
La implementación VBScript de mal se ha probado en Windows 10 1909. install.vbs puede ayudarle a instalar los requisitos (.NET 2.0 3.0 3.5). Si no ha instalado .NET 2.0 3.0 3.5 , aparecerá una ventana emergente para la instalación. Si ya lo instaló, no hará nada.
cd implsvbs
install.vbs
cscript -nologo stepX_YYY.vbs
La implementación de WebAssembly está escrita en Wam (lenguaje de macros de WebAssembly) y se ejecuta en varias incrustaciones (tiempos de ejecución) diferentes que no son web: 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
La implementación XSLT de mal está escrita con XSLT 3 y probada en Saxon 9.9.1.6 Home Edition.
cd impls/xslt
STEP=stepX_YY ./run
La implementación de mal en Wren se probó en Wren 0.2.0.
cd impls/wren
wren ./stepX_YYY.wren
La implementación de mal en Yorick se probó en Yorick 2.2.04.
cd impls/yorick
yorick -batch ./stepX_YYY.i
La implementación Zig de mal se probó en Zig 0.5.
cd impls/zig
zig build stepX_YYY
El Makefile de nivel superior tiene una serie de objetivos útiles para ayudar con el desarrollo y las pruebas de implementación. El objetivo help proporciona una lista de los objetivos y opciones:
make help
Hay casi 800 pruebas funcionales genéricas (para todas las implementaciones) en el directorio tests/ . Cada paso tiene un archivo de prueba correspondiente que contiene pruebas específicas de ese paso. El arnés de prueba runtest.py inicia una implementación de paso Mal y luego envía las pruebas una a la vez a la implementación y compara el valor de salida/retorno con el valor de salida/retorno esperado.
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 como la implementación de la prueba y usa la variable make MAL_IMPL para cambiar el idioma del host subyacente (el valor predeterminado es 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 : make "repl^IMPL"
# e.g
make "repl^ruby"
make "repl^ps"
mal como la implementación de REPL y use la variable make MAL_IMPL para cambiar el idioma del host subyacente (el valor predeterminado es 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"
Advertencia: Estas pruebas de rendimiento no son estadísticamente válidas ni exhaustivas; El rendimiento en tiempo de ejecución no es un objetivo principal de mal. Si saca alguna conclusión seria de estas pruebas de rendimiento, comuníquese conmigo acerca de alguna propiedad increíble frente al mar en Kansas que esté dispuesto a venderle por poco dinero.
make "perf^IMPL"
# e.g.
make "perf^js"
make "perf"
make "stats^IMPL"
# e.g.
make "stats^js"
Cada directorio de implementación contiene un Dockerfile para crear una imagen de Docker que contiene todas las dependencias para esa implementación. Además, el Makefile de nivel superior contiene soporte para ejecutar el objetivo de pruebas (y rendimiento, estadísticas, respuesta, etc.) dentro de un contenedor acoplable para esa implementación pasando "DOCKERIZE=1" en la línea de comando make. Por ejemplo:
make DOCKERIZE=1 "test^js^step3"
Las implementaciones existentes ya tienen imágenes de Docker creadas y enviadas al registro de Docker. Sin embargo, si desea crear o reconstruir una imagen de Docker localmente, el Makefile de nivel superior proporciona una regla para crear imágenes de Docker:
make "docker-build^IMPL"
Notas :
make DOCKERIZE=1 "repl^IMPL" antes de poder ejecutar pruebas porque es necesario descargar las dependencias del tiempo de ejecución para evitar tiempo de espera de las pruebas. Estas dependencias se descargan en archivos punto en el directorio /mal para que persistan entre ejecuciones. Mal (make-a-lisp) tiene la licencia MPL 2.0 (Licencia pública de Mozilla 2.0). Consulte LICENCIA.txt para obtener más detalles.
