mal
1.0.0
1. Mal é um intérprete Lisp inspirado em Clojure
2. Mal é uma ferramenta de aprendizagem
Cada implementação do mal é separada em 11 etapas incrementais, independentes (e testáveis) que demonstram os conceitos básicos do Lisp. A última etapa é capaz de auto-hospedar (executar a implementação mal de mal). Consulte o guia do processo make-a-lisp.
As etapas do make-a-lisp são:
Cada etapa do make-a-lisp possui um diagrama arquitetônico associado. Os elementos novos para essa etapa são destacados em vermelho. Aqui está a arquitetura final assim que a etapa A for concluída:
Se você estiver interessado em criar uma implementação mal (ou apenas interessado em usar mal para alguma coisa), você está convidado a se juntar ao nosso Discord. Além do guia do processo make-a-lisp, há também um FAQ mal/make-a-lisp onde tento responder algumas perguntas comuns.
3. Mal é implementado em 88 idiomas (94 implementações diferentes e 117 modos de execução)
| Linguagem | Criador |
|---|---|
| Ada | Chris Moore |
| Ada #2 | Nicolas Boulenguez |
| GNU Awk | Mitsuru Kariya |
| Bash 4 | Joel Martins |
| BÁSICO (C64 e QBásico) | Joel Martins |
| BBC BÁSICO V | Ben Harris |
| C | Joel Martins |
| C#2 | Duncan Watts |
| C++ | Stephen Thirlwall |
| C# | Joel Martins |
| Mandril | Vasilij Schneidermann |
| Clojure (Clojure e ClojureScript) | Joel Martins |
| CaféScript | Joel Martins |
| Lisp comum | 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 Martins |
| F# | Pedro Stephens |
| Fator | Jordan Lewis |
| Fantasma | Dov Murik |
| Funcho | sogaiu |
| Adiante | Chris Houser |
| GNU Guile | Mu Lei |
| GNU Smalltalk | Vasilij Schneidermann |
| Ir | Joel Martins |
| Legal | Joel Martins |
| Haskell | Joel Martins |
| Haxe (Neko, Python, C++ e JS) | Joel Martins |
| Olá | Joel Martins |
| Eu | Dov Murik |
| Janete | sogaiu |
| Java | Joel Martins |
| Trufa Java (Truffle/GraalVM) | Matt McGill |
| JavaScript (demonstração) | Joel Martins |
| jq | Ali Mohammad Pur |
| Júlia | Joel Martins |
| Kotlin | Javier Fernández-Ivern |
| LaTeX3 | Nicolas Boulenguez |
| LiveScript | José van Bakel |
| Logotipo | Dov Murik |
| Lua | Joel Martins |
| GNU Make | Joel Martins |
| mal em si | Joel Martins |
| MATLAB (GNU Oitava e MATLAB) | Joel Martins |
| miniMAL (repositório, demonstração) | Joel Martins |
| NASM | Ben Dudson |
| Nim | Dennis Felsing |
| Objeto Pascal | Joel Martins |
| Objetivo C | Joel Martins |
| OCaml | Chris Houser |
| Perl | Joel Martins |
| Perl 6 | Hinrik Örn Sigurðsson |
| PHP | Joel Martins |
| Picolisp | Vasilij Schneidermann |
| Pique | Dov Murik |
| PL/pgSQL (PostgreSQL) | Joel Martins |
| PL/SQL (Oracle) | Joel Martins |
| PostScript | Joel Martins |
| PowerShell | Joel Martins |
| Prólogo | Nicolas Boulenguez |
| PuroScript | Mrsekut |
| Python2 | Joel Martins |
| Python3 | Gavin Lewis |
| RPython | Joel Martins |
| R | Joel Martins |
| Raquete | Joel Martins |
| Rexx | Dov Murik |
| Rubi | Joel Martins |
| Rubi #2 | Ryan Cook |
| Ferrugem | Joel Martins |
| escala | Joel Martins |
| Esquema (R7RS) | Vasilij Schneidermann |
| Inclinação | Dov Murik |
| ML padrão | Fabian Bergström |
| Rápido 3 | Joel Martins |
| Rápido 4 | 陆遥 |
| Rápido 6 | Oleg Montak |
| Tcl | Dov Murik |
| Texto datilografado | Masahiro Wakame |
| Vala | Simon Tatham |
| VHDL | Dov Murik |
| Vimscript | Dov Murik |
| Visual Basic.NET | Joel Martins |
| Script Visual Básico | 刘百超 |
| WebAssembly (wasm) | Joel Martins |
| Carriça | Dov Murik |
| XSLT | Ali Mohammad Pur |
| Yorick | Dov Murik |
| Ziguezague | Josh Tobin |
Mal foi apresentado publicamente pela primeira vez em uma palestra relâmpago no Clojure West 2014 (infelizmente não há vídeo). Veja exemplos/clojurewest2014.mal para a apresentação que foi feita na conferência (sim, a apresentação é um programa mal).
No Midwest.io 2015, Joel Martin fez uma apresentação sobre Mal intitulada "Achievement Unlocked: A Better Path to Language Learning". Vídeo, Apresentações.
Mais recentemente, Joel fez uma apresentação sobre "Faça seu próprio interpretador Lisp em 10 etapas incrementais" na LambdaConf 2016: Parte 1, Parte 2, Parte 3, Parte 4, Slides.
A maneira mais simples de executar qualquer implementação é usar o docker. Cada implementação possui uma imagem docker pré-construída com dependências de linguagem instaladas. Você pode iniciar o REPL usando um destino conveniente no Makefile de nível superior (onde IMPL é o nome do diretório de implementação e stepX é a etapa a ser executada):
make DOCKERIZE=1 "repl^IMPL^stepX"
# OR stepA is the default step:
make DOCKERIZE=1 "repl^IMPL"
As seguintes implementações são mantidas como projetos separados:
A implementação Ada foi desenvolvida com GNAT 4.9 no debian. Ele também compila inalterado no Windows se você tiver versões do Windows do git, GNAT e (opcionalmente) make. Não há dependências externas (readline não implementado).
cd impls/ada
make
./stepX_YYY
A segunda implementação do Ada foi desenvolvida com GNAT 8 e vinculada à biblioteca GNU readline.
cd impls/ada
make
./stepX_YYY
A implementação GNU awk do mal foi testada com GNU awk 4.1.1.
cd impls/gawk
gawk -O -f stepX_YYY.awk
cd impls/bash
bash stepX_YYY.sh
A implementação BASIC usa um pré-processador que pode gerar código BASIC compatível com C64 BASIC (CBM v2) ou QBasic. O modo C64 foi testado com cbmbasic (a versão corrigida é atualmente necessária para corrigir problemas com entrada de linha) e o modo QBasic foi testado com FreeBASIC.
Gere o código C64 e execute-o usando cbmbasic:
cd impls/basic
make MODE=cbm stepX_YYY.bas
STEP=stepX_YYY basic_MODE=cbm ./run
Gere código QBasic, compile usando FreeBASIC e execute-o:
cd impls/basic
make MODE=qbasic stepX_YYY.bas
make MODE=qbasic stepX_YYY
./stepX_YYY
Obrigado a Steven Syrek pela inspiração original para esta implementação.
A implementação BBC BASIC V pode ser executada no intérprete Brandy:
cd impls/bbc-basic
brandy -quit stepX_YYY.bbc
Ou no ARM BBC BASIC V no RISC OS 3 ou posterior:
*Dir bbc-basic.riscos
*Run setup
*Run stepX_YYY
A implementação C do mal requer as seguintes bibliotecas (pacotes lib e de cabeçalho): glib, libffi6, libgc e a biblioteca libedit ou GNU readline.
cd impls/c
make
./stepX_YYY
A segunda implementação C do mal requer as seguintes bibliotecas (pacotes lib e de cabeçalho): libedit, libgc, libdl e libffi.
cd impls/c.2
make
./stepX_YYY
A implementação C++ do mal requer g++-4.9 ou clang++-3.5 e uma biblioteca compatível com readline para ser construída. Consulte o cpp/README.md para obter mais detalhes:
cd impls/cpp
make
# OR
make CXX=clang++-3.5
./stepX_YYY
A implementação C# do mal foi testada no Linux usando o compilador Mono C# (mcs) e o tempo de execução Mono (versão 2.10.8.1). Ambos são necessários para criar e executar a implementação do C#.
cd impls/cs
make
mono ./stepX_YYY.exe
A implementação do ChucK foi testada com o ChucK 1.3.5.2.
cd impls/chuck
./run
Na maior parte, a implementação do Clojure requer o Clojure 1.5, no entanto, para passar em todos os testes, é necessário o 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
A implementação foi testada com SBCL, CCL, CMUCL, GNU CLISP, ECL e Allegro CL no Ubuntu 16.04 e Ubuntu 12.04, consulte o README para mais detalhes. Desde que você tenha as dependências mencionadas instaladas, faça o seguinte para executar a implementação
cd impls/common-lisp
make
./run
A implementação Crystal do mal foi testada com Crystal 0.26.1.
cd impls/crystal
crystal run ./stepX_YYY.cr
# OR
make # needed to run tests
./stepX_YYY
A implementação D do mal foi testada com GDC 4.8. Requer a biblioteca readline GNU.
cd impls/d
make
./stepX_YYY
A implementação do Dart foi testada com o Dart 1.20.
cd impls/dart
dart ./stepX_YYY
A implementação do mal no Emacs Lisp foi testada com o Emacs 24.3 e 24.5. Embora exista uma edição de readline muito básica ( <backspace> e Cd funcionam, Cc cancela o processo), é recomendado usar rlwrap .
cd impls/elisp
emacs -Q --batch --load stepX_YYY.el
# with full readline support
rlwrap emacs -Q --batch --load stepX_YYY.el
A implementação do mal no Elixir foi testada com o Elixir 1.0.5.
cd impls/elixir
mix stepX_YYY
# Or with readline/line editing functionality:
iex -S mix stepX_YYY
A implementação Elm do mal foi testada com Elm 0.18.0
cd impls/elm
make stepX_YYY.js
STEP=stepX_YYY ./run
A implementação do mal em Erlang requer Erlang/OTP R17 e vergalhão para ser construída.
cd impls/erlang
make
# OR
MAL_STEP=stepX_YYY rebar compile escriptize # build individual step
./stepX_YYY
A implementação ES6/ECMAScript 2015 usa o compilador babel para gerar JavaScript compatível com ES5. O código gerado foi testado com o Node 0.12.4.
cd impls/es6
make
node build/stepX_YYY.js
A implementação F# do mal foi testada no Linux usando o compilador Mono F# (fsharpc) e o tempo de execução Mono (versão 3.12.1). O compilador mono C# (mcs) também é necessário para compilar a dependência readline. Todos são necessários para compilar e executar a implementação do F#.
cd impls/fsharp
make
mono ./stepX_YYY.exe
A implementação do Fator mal foi testada com o Fator 0,97 (factorcode.org).
cd impls/factor
FACTOR_ROOTS=. factor -run=stepX_YYY
A implementação do Mal no Fantom foi testada com o Fantom 1.0.70.
cd impls/fantom
make lib/fan/stepX_YYY.pod
STEP=stepX_YYY ./run
A implementação do Mal no Fennel foi testada com o Fennel versão 0.9.1 em 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
A implementação Smalltalk do mal foi testada com GNU Smalltalk 3.2.91.
cd impls/gnu-smalltalk
./run
A implementação do mal em Go requer que o go esteja instalado no caminho. A implementação foi testada com Go 1.3.1.
cd impls/go
make
./stepX_YYY
A implementação Groovy do mal requer que o Groovy seja executado e foi testada com o Groovy 1.8.6.
cd impls/groovy
make
groovy ./stepX_YYY.groovy
A implementação Haskell requer o compilador ghc versão 7.10.1 ou posterior e também os pacotes Haskell parsec e readline (ou editline).
cd impls/haskell
make
./stepX_YYY
A implementação Haxe do mal requer Haxe versão 3.2 para compilar. Quatro alvos Haxe diferentes são suportados: Neko, Python, C++ e 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
A implementação Hy do mal foi testada com Hy 0.13.0.
cd impls/hy
./stepX_YYY.hy
A implementação Io do mal foi testada com Io versão 20110905.
cd impls/io
io ./stepX_YYY.io
A implementação do mal pela Janet foi testada com a versão 1.12.2 da Janet.
cd impls/janet
janet ./stepX_YYY.janet
A implementação Java do mal requer maven2 para ser construída.
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 implementação Java será executada no OpenJDK, mas pode ser executada até 30x mais rápido no GraalVM graças ao framework Truffle. Foi testado com OpenJDK 11, GraalVM CE 20.1.0 e GraalVM CE 21.1.0.
cd impls/java-truffle
./gradlew build
STEP=stepX_YYY ./run
cd impls/js
npm install
node stepX_YYY.js
A implementação Julia de mal requer Julia 0.4.
cd impls/julia
julia stepX_YYY.jl
Testado na versão 1.6, com muitas trapaças no departamento de IO
cd impls/jq
STEP=stepA_YYY ./run
# with Debug
DEBUG=true STEP=stepA_YYY ./run
A implementação do mal em Kotlin foi testada com Kotlin 1.0.
cd impls/kotlin
make
java -jar stepX_YYY.jar
A implementação LaTeX3 do mal foi testada com pdfTeX 3.141592653-2.6-1.40.24.
A auto-hospedagem é muito lenta para qualquer tempo limite razoável e trava na etapa 4, aparentemente devido a limitações embutidas no código.
Qualquer pessoa que esteja trabalhando nisso deve descomentar as duas linhas de opções de depuração (lenta) no arquivo de etapas e export DEBUG=1 (para obter mais resultados do que os testes aceitam).
A implementação LiveScript do mal foi testada com LiveScript 1.5.
cd impls/livescript
make
node_modules/.bin/lsc stepX_YYY.ls
A implementação do Logo do mal foi testada com UCLogo 6.0.
cd impls/logo
logo stepX_YYY.lg
A implementação Lua do mal foi testada com Lua 5.3.5. A implementação requer a instalação de luarocks.
cd impls/lua
make # to build and link linenoise.so and rex_pcre.so
./stepX_YYY.lua
Executar a implementação mal de mal envolve executar a etapa A de uma das outras implementações e passar a etapa mal para executar como um argumento de linha de comando.
cd impls/IMPL
IMPL_STEPA_CMD ../mal/stepX_YYY.mal
cd impls/make
make -f stepX_YYY.mk
A implementação NASM do mal foi escrita para Linux x86-64 e foi testada com Linux 3.16.0-4-amd64 e NASM versão 2.11.05.
cd impls/nasm
make
./stepX_YYY
A implementação do mal no Nim foi testada com o Nim 1.0.4.
cd impls/nim
make
# OR
nimble build
./stepX_YYY
A implementação Object Pascal do mal foi construída e testada em Linux usando o compilador Free Pascal versão 2.6.2 e 2.6.4.
cd impls/objpascal
make
./stepX_YYY
A implementação Objective C do mal foi construída e testada em Linux usando clang/LLVM 3.6. Ele também foi construído e testado no OS X usando o Xcode 7.
cd impls/objc
make
./stepX_YYY
cd impls/ocaml
make
./stepX_YYY
A implementação do MatLab foi testada com GNU Octave 4.2.1. Também foi testado com MATLAB versão R2014a no Linux. Observe que o MATLAB é um produto 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 é um pequeno interpretador Lisp implementado em menos de 1024 bytes de JavaScript. Para executar a implementação miniMAL do mal, você precisa baixar/instalar o interpretador miniMAL (que requer 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
A implementação do Perl 5 deve funcionar com o Perl 5.19.3 e posterior.
Para suporte à edição de linha readline, instale Term::ReadLine::Perl ou Term::ReadLine::Gnu do CPAN.
cd impls/perl
perl stepX_YYY.pl
A implementação do Perl 6 foi testada no Rakudo Perl 6 2016.04.
cd impls/perl6
perl6 stepX_YYY.pl
A implementação de mal em PHP requer a interface de linha de comando php para ser executada.
cd impls/php
php stepX_YYY.php
A implementação do Picolisp requer libreadline e Picolisp 3.1.11 ou posterior.
cd impls/picolisp
./run
A implementação do Pike foi testada no Pike 8.0.
cd impls/pike
pike stepX_YYY.pike
A implementação PL/pgSQL do mal requer um servidor PostgreSQL em execução (a imagem docker "kanaka/mal-test-plpgsql" inicia automaticamente um servidor PostgreSQL). A implementação se conecta ao servidor PostgreSQL e cria um banco de dados denominado “mal” para armazenar tabelas e procedimentos armazenados. O script wrapper usa o comando psql para conectar-se ao servidor e o padrão é o usuário "postgres", mas isso pode ser substituído pela variável de ambiente PSQL_USER. Uma senha pode ser especificada usando a variável de ambiente PGPASSWORD. A implementação foi testada com PostgreSQL 9.4.
cd impls/plpgsql
./wrap.sh stepX_YYY.sql
# OR
PSQL_USER=myuser PGPASSWORD=mypass ./wrap.sh stepX_YYY.sql
A implementação PL/SQL do mal requer um servidor Oracle DB em execução (a imagem docker "kanaka/mal-test-plsql" inicia automaticamente um servidor Oracle Express). A implementação se conecta ao servidor Oracle para criar tipos, tabelas e procedimentos armazenados. O valor de logon padrão do SQL*Plus (nomedeusuário/senha@connect_identifier) é "system/oracle", mas pode ser substituído pela variável de ambiente ORACLE_LOGON. A implementação foi testada com o Oracle Express Edition 11g Release 2. Observe que quaisquer avisos de conexão SQL*Plus (expiração de senha do usuário, etc.) interferirão na capacidade do script wrapper de se comunicar com o banco de dados.
cd impls/plsql
./wrap.sh stepX_YYY.sql
# OR
ORACLE_LOGON=myuser/mypass@ORCL ./wrap.sh stepX_YYY.sql
A implementação PostScript do mal requer que o Ghostscript seja executado. Foi testado com Ghostscript 9.10.
cd impls/ps
gs -q -dNODISPLAY -I./ stepX_YYY.ps
A implementação do Mal no PowerShell requer a linguagem de script do PowerShell. Foi testado com PowerShell 6.0.0 Alpha 9 no Linux.
cd impls/powershell
powershell ./stepX_YYY.ps1
A implementação do Prolog usa algumas construções específicas do SWI-Prolog, inclui suporte readline e foi testada no Debian GNU/Linux com versão 8.2.1.
cd impls/prolog
swipl stepX_YYY
A implementação do PureScript requer o compilador spago versão 0.20.2.
cd impls/purs
make
node ./stepX_YYY.js
Esta implementação usa apenas recursos do python2, mas evita incompatibilidades com o python3.
Esta implementação é verificada quanto ao estilo e tipos (flake8, pylint, mypy). Ele relata todos os erros com detalhes. Demonstra iteradores, decoradores, ferramentas funcionais, mapas de cadeia, classes de dados, introspecção, instruções de correspondência, expressões de atribuição.
Você deve ter o rpython no seu caminho (incluído no pypy).
cd impls/rpython
make # this takes a very long time
./stepX_YYY
A implementação R de mal requer R (r-base-core) para ser executado.
cd impls/r
make libs # to download and build rdyncall
Rscript stepX_YYY.r
A implementação do mal no Racket requer que o compilador/interpretador Racket seja executado.
cd impls/racket
./stepX_YYY.rkt
A implementação Rexx do mal foi testada com Regina Rexx 3.6.
cd impls/rexx
make
rexx -a ./stepX_YYY.rexxpp
cd impls/ruby
ruby stepX_YYY.rb
Uma segunda implementação Ruby com os seguintes objetivos:
Mal cd impls/ruby.2
ruby stepX_YYY.rb
A implementação de ferrugem do mal requer o compilador de ferrugem e a ferramenta de construção (carga) para construir.
cd impls/rust
cargo run --release --bin stepX_YYY
Instale scala e 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
A implementação do Scheme do MAL foi testada com Chibi-Scheme 0.10, Kawa 3.1.1, Gauche 0.9.6, CHICKEN 5.1.0, Sagittarius 0.9.7, Cyclone 0.32.0 (versão Git) e Foment 0.4 (versão Git). Você deve conseguir executá-lo em outras implementações R7RS em conformidade depois de descobrir como as bibliotecas são carregadas e ajustar o Makefile e run o script de acordo.
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
A implementação Skew do mal foi testada com Skew 0.7.42.
cd impls/skew
make
node stepX_YYY.js
A implementação Standard ML de mal requer uma implementação SML97. O Makefile suporta Poly/ML, MLton, Moscow ML e foi testado com Poly/ML 5.8.1, MLton 20210117 e Moscow ML versão 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
A implementação do mal no Swift 3 requer o compilador Swift 3.0. Foi testado com Swift 3 Preview 3.
cd impls/swift3
make
./stepX_YYY
A implementação do mal no Swift 4 requer o compilador Swift 4.0. Ele foi testado com a versão Swift 4.2.3.
cd impls/swift4
make
./stepX_YYY
A implementação do mal no Swift 5 requer o compilador Swift 5.0. Ele foi testado com a versão Swift 5.1.1.
cd impls/swift6
swift run stepX_YYY
A implementação Tcl do mal requer o Tcl 8.6 para ser executado. Para suporte à edição de linha readline, instale tclreadline.
cd impls/tcl
tclsh ./stepX_YYY.tcl
A implementação TypeScript de mal requer o compilador TypeScript 2.2. Ele foi testado com Node.js v6.
cd impls/ts
make
node ./stepX_YYY.js
A implementação Vala do mal foi testada com o compilador Vala 0.40.8. Você precisará instalar valac e libreadline-dev ou equivalente.
cd impls/vala
make
./stepX_YYY
A implementação VHDL do mal foi testada com GHDL 0.29.
cd impls/vhdl
make
./run_vhdl.sh ./stepX_YYY
A implementação do mal no Vimscript requer o Vim 8.0 para ser executado.
cd impls/vimscript
./run_vimscript.sh ./stepX_YYY.vim
A implementação VB.NET do mal foi testada no Linux usando o compilador Mono VB (vbnc) e o tempo de execução Mono (versão 2.10.8.1). Ambos são necessários para construir e executar a implementação do VB.NET.
cd impls/vb
make
mono ./stepX_YYY.exe
A implementação VBScript do mal foi testada no Windows 10 1909. install.vbs pode ajudá-lo a instalar os requisitos (.NET 2.0 3.0 3.5). Se você não instalou .NET 2.0 3.0 3.5 , aparecerá uma janela para instalação. Se você já instalou isso, não fará nada.
cd implsvbs
install.vbs
cscript -nologo stepX_YYY.vbs
A implementação do WebAssembly é escrita em Wam (linguagem WebAssembly Macro) e é executada em vários embeddings (tempos de execução) diferentes da 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
A implementação XSLT do mal foi escrita com XSLT 3 e testada no Saxon 9.9.1.6 Home Edition.
cd impls/xslt
STEP=stepX_YY ./run
A implementação de mal do Wren foi testada no Wren 0.2.0.
cd impls/wren
wren ./stepX_YYY.wren
A implementação do mal no Yorick foi testada no Yorick 2.2.04.
cd impls/yorick
yorick -batch ./stepX_YYY.i
A implementação Zig do mal foi testada no Zig 0.5.
cd impls/zig
zig build stepX_YYY
O Makefile de nível superior possui vários alvos úteis para auxiliar no desenvolvimento e teste da implementação. O alvo help fornece uma lista de alvos e opções:
make help
Existem quase 800 testes funcionais genéricos (para todas as implementações) no diretório tests/ . Cada etapa possui um arquivo de teste correspondente contendo testes específicos para aquela etapa. O equipamento de teste runtest.py inicia uma implementação de etapa Mal e, em seguida, alimenta os testes um de cada vez para a implementação e compara o valor de saída/retorno com o valor de saída/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 a implementação do teste e use a variável make MAL_IMPL para alterar o idioma do host subjacente (o padrão é 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 será usada: make "repl^IMPL"
# e.g
make "repl^ruby"
make "repl^ps"
mal como a implementação REPL e use a variável make MAL_IMPL para alterar o idioma do host subjacente (o padrão é 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"
Aviso: Esses testes de desempenho não são estatisticamente válidos nem abrangentes; o desempenho em tempo de execução não é o objetivo principal do mal. Se você tirar alguma conclusão séria desses testes de desempenho, entre em contato comigo sobre alguma propriedade incrível à beira-mar no Kansas que estou disposto a vender a você por um preço barato.
make "perf^IMPL"
# e.g.
make "perf^js"
make "perf"
make "stats^IMPL"
# e.g.
make "stats^js"
Cada diretório de implementação contém um Dockerfile para criar uma imagem docker contendo todas as dependências dessa implementação. Além disso, o Makefile de nível superior contém suporte para executar o alvo de testes (e perf, stats, repl, etc.) dentro de um contêiner docker para essa implementação, passando "DOCKERIZE=1" na linha de comando do make. Por exemplo:
make DOCKERIZE=1 "test^js^step3"
As implementações existentes já possuem imagens do docker construídas e enviadas para o registro do docker. No entanto, se você deseja construir ou reconstruir uma imagem docker localmente, o Makefile de nível superior fornece uma regra para construir imagens docker:
make "docker-build^IMPL"
Notas :
make DOCKERIZE=1 "repl^IMPL" antes de poder executar testes porque as dependências de tempo de execução precisam ser baixadas para evitar o os testes expiram. Essas dependências são baixadas em arquivos de ponto no diretório /mal para que persistam entre as execuções. Mal (make-a-lisp) é licenciado sob MPL 2.0 (Mozilla Public License 2.0). Consulte LICENSE.txt para obter mais detalhes.
