3 [![Build Status](https://travis-ci.org/kanaka/mal.svg?branch=master)](https://travis-ci.org/kanaka/mal)
7 **1. Mal is a Clojure inspired Lisp interpreter**
9 **2. Mal is implemented in 74 languages**
11 | Language | Creator |
12 | -------- | ------- |
13 | [Ada](#ada) | [Chris Moore](https://github.com/zmower) |
14 | [GNU awk](#gnu-awk) | [Miutsuru Kariya](https://github.com/kariya-mitsuru) |
15 | [Bash 4](#bash-4) | [Joel Martin](https://github.com/kanaka) |
16 | [BASIC](#basic-c64-and-qbasic) (C64 & QBasic) | [Joel Martin](https://github.com/kanaka) |
17 | [C](#c) | [Joel Martin](https://github.com/kanaka) |
18 | [C++](#c-1) | [Stephen Thirlwall](https://github.com/sdt) |
19 | [C#](#c-2) | [Joel Martin](https://github.com/kanaka) |
20 | [ChucK](#chuck) | [Vasilij Schneidermann](https://github.com/wasamasa) |
21 | [Common Lisp](#common-lisp) | [Iqbal Ansari](https://github.com/iqbalansari) |
22 | [Clojure](#clojure) (Clojure & ClojureScript) | [Joel Martin](https://github.com/kanaka) |
23 | [CoffeeScript](#coffeescript) | [Joel Martin](https://github.com/kanaka) |
24 | [Crystal](#crystal) | [Linda_pp](https://github.com/rhysd) |
25 | [D](#d) | [Dov Murik](https://github.com/dubek) |
26 | [Dart](#dart) | [Harry Terkelsen](https://github.com/hterkelsen) |
27 | [Elixir](#elixir) | [Martin Ek](https://github.com/ekmartin) |
28 | [Elm](#elm) | [Jos van Bakel](https://github.com/c0deaddict) |
29 | [Emacs Lisp](#emacs-lisp) | [Vasilij Schneidermann](https://github.com/wasamasa) |
30 | [Erlang](#erlang) | [Nathan Fiedler](https://github.com/nlfiedler) |
31 | [ES6](#es6-ecmascript-2015) (ECMAScript 2015) | [Joel Martin](https://github.com/kanaka) |
32 | [F#](#f) | [Peter Stephens](https://github.com/pstephens) |
33 | [Factor](#factor) | [Jordan Lewis](https://github.com/jordanlewis) |
34 | [Fantom](#fantom) | [Dov Murik](https://github.com/dubek) |
35 | [Forth](#forth) | [Chris Houser](https://github.com/chouser) |
36 | [Go](#go) | [Joel Martin](https://github.com/kanaka) |
37 | [Groovy](#groovy) | [Joel Martin](https://github.com/kanaka) |
38 | [GNU Guile](#gnu-guile-21) | [Mu Lei](https://github.com/NalaGinrut) |
39 | [GNU Smalltalk](#gnu-smalltalk) | [Vasilij Schneidermann](https://github.com/wasamasa) |
40 | [Haskell](#haskell) | [Joel Martin](https://github.com/kanaka) |
41 | [Haxe](#haxe-neko-python-c-and-javascript) (Neko, Python, C++, & JS) | [Joel Martin](https://github.com/kanaka) |
42 | [Hy](#hy) | [Joel Martin](https://github.com/kanaka) |
43 | [Io](#io) | [Dov Murik](https://github.com/dubek) |
44 | [Java](#java-17) | [Joel Martin](https://github.com/kanaka) |
45 | [JavaScript](#javascriptnode) ([Demo](http://kanaka.github.io/mal)) | [Joel Martin](https://github.com/kanaka) |
46 | [Julia](#julia) | [Joel Martin](https://github.com/kanaka) |
47 | [Kotlin](#kotlin) | [Javier Fernandez-Ivern](https://github.com/ivern) |
48 | [LiveScript](#livescript) | [Jos van Bakel](https://github.com/c0deaddict) |
49 | [Logo](#logo) | [Dov Murik](https://github.com/dubek) |
50 | [Lua](#lua) | [Joel Martin](https://github.com/kanaka) |
51 | [GNU Make](#gnu-make-381) | [Joel Martin](https://github.com/kanaka) |
52 | [mal itself](#mal) | [Joel Martin](https://github.com/kanaka) |
53 | [Matlab](#matlab-gnu-octave-and-matlab) (GNU Octave & MATLAB) | [Joel Martin](https://github.com/kanaka) |
54 | [miniMAL](#minimal) ([Repo](https://github.com/kanaka/miniMAL), [Demo](https://kanaka.github.io/miniMAL/)) | [Joel Martin](https://github.com/kanaka) |
55 | [NASM](#nasm) | [Ben Dudson](https://github.com/bendudson) |
56 | [Nim](#nim-0170) | [Dennis Felsing](https://github.com/def-) |
57 | [Object Pascal](#object-pascal) | [Joel Martin](https://github.com/kanaka) |
58 | [Objective C](#objective-c) | [Joel Martin](https://github.com/kanaka) |
59 | [OCaml](#ocaml-4010) | [Chris Houser](https://github.com/chouser) |
60 | [Perl](#perl-58) | [Joel Martin](https://github.com/kanaka) |
61 | [Perl 6](#perl-6) | [Hinrik Örn Sigurðsson](https://github.com/hinrik) |
62 | [PHP](#php-53) | [Joel Martin](https://github.com/kanaka) |
63 | [Picolisp](#picolisp) | [Vasilij Schneidermann](https://github.com/wasamasa) |
64 | [PL/pgSQL](#plpgsql-postgres-sql-procedural-language) (Postgres) | [Joel Martin](https://github.com/kanaka) |
65 | [PL/SQL](#plsql-oracle-sql-procedural-language) (Oracle) | [Joel Martin](https://github.com/kanaka) |
66 | [Postscript](#postscript-level-23) | [Joel Martin](https://github.com/kanaka) |
67 | [PowerShell](#powershell) | [Joel Martin](https://github.com/kanaka) |
68 | [Python](#python-2x-and-3x) (2.X & 3.X) | [Joel Martin](https://github.com/kanaka) |
69 | [RPython](#rpython) | [Joel Martin](https://github.com/kanaka) |
70 | [R](#r) | [Joel Martin](https://github.com/kanaka) |
71 | [Racket](#racket-53) | [Joel Martin](https://github.com/kanaka) |
72 | [Rexx](#rexx) | [Dov Murik](https://github.com/dubek) |
73 | [Ruby](#ruby-19) | [Joel Martin](https://github.com/kanaka) |
74 | [Rust](#rust-100-nightly) | [Joel Martin](https://github.com/kanaka) |
75 | [Scala](#scala) | [Joel Martin](https://github.com/kanaka) |
76 | [Scheme (R7RS)](#scheme-r7rs) | [Vasilij Schneidermann](https://github.com/wasamasa) |
77 | [Skew](#skew) | [Dov Murik](https://github.com/dubek) |
78 | [Swift](#swift) | [Keith Rollin](https://github.com/keith-rollin) |
79 | [Swift 3](#swift-3) | [Joel Martin](https://github.com/kanaka) |
80 | [Tcl](#tcl-86) | [Dov Murik](https://github.com/dubek) |
81 | [TypeScript](#typescript) | [Masahiro Wakame](https://github.com/vvakame) |
82 | [VHDL](#vhdl) | [Dov Murik](https://github.com/dubek) |
83 | [Vimscript](#vimscript) | [Dov Murik](https://github.com/dubek) |
84 | [Visual Basic.NET](#visual-basicnet) | [Joel Martin](https://github.com/kanaka) |
85 | [WebAssembly](#webassembly-wasm) (wasm) | [Joel Martin](https://github.com/kanaka) |
86 | [Yorick](#yorick) | [Dov Murik](https://github.com/dubek) |
89 **3. Mal is a learning tool**
91 Each implementation of mal is separated into
92 11 incremental, self-contained (and testable) steps that demonstrate
93 core concepts of Lisp. The last step is capable of self-hosting
94 (running the mal implementation of mal). See the [make-a-lisp process
95 guide](process/guide.md).
97 The make-a-lisp steps are:
99 * [step0_repl](process/guide.md#step0)
100 * [step1_read_print](process/guide.md#step1)
101 * [step2_eval](process/guide.md#step2)
102 * [step3_env](process/guide.md#step3)
103 * [step4_if_fn_do](process/guide.md#step4)
104 * [step5_tco](process/guide.md#step5)
105 * [step6_file](process/guide.md#step6)
106 * [step7_quote](process/guide.md#step7)
107 * [step8_macros](process/guide.md#step8)
108 * [step9_try](process/guide.md#step9)
109 * [stepA_mal](process/guide.md#stepA)
111 Each make-a-lisp step has an associated architectural diagram. That elements
112 that are new for that step are highlighted in red.
113 Here is the final diagram for [step A](process/guide.md#stepA):
115 ![stepA_mal architecture](process/stepA_mal.png)
117 If you are interesting in creating a mal implementation (or just
118 interested in using mal for something), please drop by the #mal
119 channel on freenode. In addition to the [make-a-lisp process
120 guide](process/guide.md) there is also a [mal/make-a-lisp
121 FAQ](docs/FAQ.md) where I attempt to answer some common questions.
126 Mal was presented publicly for the first time in a lightning talk at
127 Clojure West 2014 (unfortunately there is no video). See
128 examples/clojurewest2014.mal for the presentation that was given at the
129 conference (yes, the presentation is a mal program).
131 At Midwest.io 2015, Joel Martin gave a presentation on Mal titled
132 "Achievement Unlocked: A Better Path to Language Learning".
133 [Video](https://www.youtube.com/watch?v=lgyOAiRtZGw),
134 [Slides](http://kanaka.github.io/midwest.io.mal/).
136 More recently Joel gave a presentation on "Make Your Own Lisp Interpreter
137 in 10 Incremental Steps" at LambdaConf 2016:
138 [Part 1](https://www.youtube.com/watch?v=jVhupfthTEk),
139 [Part 2](https://www.youtube.com/watch?v=X5OQBMGpaTU),
140 [Part 3](https://www.youtube.com/watch?v=6mARZzGgX4U),
141 [Part 4](https://www.youtube.com/watch?v=dCO1SYR5kDU),
142 [Slides](http://kanaka.github.io/lambdaconf/).
144 ## Building/running implementations
146 The simplest way to run any given implementation is to use docker.
147 Every implementation has a docker image pre-built with language
148 dependencies installed. You can launch the REPL using a convenient
149 target in the top level Makefile (where IMPL is the implementation
150 directory name and stepX is the step to run):
153 make DOCKERIZE=1 "repl^IMPL^stepX"
154 # OR stepA is the default step:
155 make DOCKERIZE=1 "repl^IMPL"
161 The Ada implementation was developed with GNAT 4.9 on debian. It also
162 compiles unchanged on windows if you have windows versions of git,
163 GNAT and (optionally) make. There are no external dependencies
164 (readline not implemented).
174 The GNU awk implementation of mal has been tested with GNU awk 4.1.1.
178 gawk -O -f stepX_YYY.awk
188 ### BASIC (C64 and QBasic)
190 The BASIC implementation uses a preprocessor that can generate BASIC
191 code that is compatible with both C64 BASIC (CBM v2) and QBasic. The
192 C64 mode has been tested with
193 [cbmbasic](https://github.com/kanaka/cbmbasic) (the patched version is
194 currently required to fix issues with line input) and the QBasic mode
195 has been tested with [qb64](http://www.qb64.net/).
197 Generate C64 code and run it using cbmbasic:
205 Generate QBasic code and load it into qb64:
209 make MODE=qbasic stepX_YYY.bas
213 Thanks to [Steven Syrek](https://github.com/sjsyrek) for the original
214 inspiration for this implementation.
219 The C implementation of mal requires the following libraries (lib and
220 header packages): glib, libffi6, libgc, and either the libedit or GNU readline
231 The C++ implementation of mal requires g++-4.9 or clang++-3.5 and
232 a readline compatible library to build. See the `cpp/README.md` for
246 The C# implementation of mal has been tested on Linux using the Mono
247 C# compiler (mcs) and the Mono runtime (version 2.10.8.1). Both are
248 required to build and run the C# implementation.
258 The ChucK implementation has been tested with ChucK 1.3.5.2.
267 The implementation has been tested with SBCL, CCL, CMUCL, GNU CLISP, ECL and
268 Allegro CL on Ubuntu 16.04 and Ubuntu 12.04, see
269 the [README](common-lisp/README.org) for more details. Provided you have the
270 dependencies mentioned installed, do the following to run the implementation
280 For the most part the Clojure implementation requires Clojure 1.5,
281 however, to pass all tests, Clojure 1.8.0-RC4 is required.
285 lein with-profile +stepX trampoline run
291 sudo npm install -g coffee-script
298 The Crystal implementation of mal has been tested with Crystal 0.26.1.
302 crystal run ./stepX_YYY.cr
304 make # needed to run tests
310 The D implementation of mal was tested with GDC 4.8. It requires the GNU
321 The Dart implementation has been tested with Dart 1.20.
330 The Emacs Lisp implementation of mal has been tested with Emacs 24.3
331 and 24.5. While there is very basic readline editing (`<backspace>`
332 and `C-d` work, `C-c` cancels the process), it is recommended to use
337 emacs -Q --batch --load stepX_YYY.el
338 # with full readline support
339 rlwrap emacs -Q --batch --load stepX_YYY.el
344 The Elixir implementation of mal has been tested with Elixir 1.0.5.
349 # Or with readline/line editing functionality:
355 The Elm implementation of mal has been tested with Elm 0.18.0
365 The Erlang implementation of mal requires [Erlang/OTP R17](http://www.erlang.org/download.html)
366 and [rebar](https://github.com/rebar/rebar) to build.
372 MAL_STEP=stepX_YYY rebar compile escriptize # build individual step
376 ### ES6 (ECMAScript 2015)
378 The ES6 / ECMAScript 2015 implementation uses the
379 [babel](https://babeljs.io) compiler to generate ES5 compatible
380 JavaScript. The generated code has been tested with Node 0.12.4.
385 node build/stepX_YYY.js
391 The F# implementation of mal has been tested on Linux using the Mono
392 F# compiler (fsharpc) and the Mono runtime (version 3.12.1). The mono C#
393 compiler (mcs) is also necessary to compile the readline dependency. All are
394 required to build and run the F# implementation.
404 The Factor implementation of mal has been tested with Factor 0.97
405 ([factorcode.org](http://factorcode.org)).
409 FACTOR_ROOTS=. factor -run=stepX_YYY
414 The Fantom implementation of mal has been tested with Fantom 1.0.70.
418 make lib/fan/stepX_YYY.pod
431 The Go implementation of mal requires that go is installed on on the
432 path. The implementation has been tested with Go 1.3.1.
443 The Groovy implementation of mal requires Groovy to run and has been
444 tested with Groovy 1.8.6.
449 groovy ./stepX_YYY.groovy
456 guile -L ./ stepX_YYY.scm
461 The Smalltalk implementation of mal has been tested with GNU Smalltalk 3.2.91.
470 The Haskell implementation requires the ghc compiler version 7.10.1 or
471 later and also the Haskell parsec and readline (or editline) packages.
479 ### Haxe (Neko, Python, C++ and JavaScript)
481 The Haxe implementation of mal requires Haxe version 3.2 to compile.
482 Four different Haxe targets are supported: Neko, Python, C++, and
492 python3 ./stepX_YYY.py
503 The Hy implementation of mal has been tested with Hy 0.13.0.
512 The Io implementation of mal has been tested with Io version 20110905.
521 The Java implementation of mal requires maven2 to build.
526 mvn -quiet exec:java -Dexec.mainClass=mal.stepX_YYY
528 mvn -quiet exec:java -Dexec.mainClass=mal.stepX_YYY -Dexec.args="CMDLINE_ARGS"
541 The Julia implementation of mal requires Julia 0.4.
550 The Kotlin implementation of mal has been tested with Kotlin 1.0.
555 java -jar stepX_YYY.jar
560 The LiveScript implementation of mal has been tested with LiveScript 1.5.
565 node_modules/.bin/lsc stepX_YYY.ls
570 The Logo implementation of mal has been tested with UCBLogo 6.0.
579 The Lua implementation of mal has been tested with Lua 5.2. The
580 implementation requires that luarocks and the lua-rex-pcre library
585 make # to build and link linenoise.so
591 Running the mal implementation of mal involves running stepA of one of
592 the other implementations and passing the mal step to run as a command
597 IMPL_STEPA_CMD ../mal/stepX_YYY.mal
610 The NASM implementation of mal is written for x86-64 Linux, and has been tested
611 with Linux 3.16.0-4-amd64 and NASM version 2.11.05.
621 The Nim implementation of mal has been tested with Nim 0.17.0.
633 The Object Pascal implementation of mal has been built and tested on
634 Linux using the Free Pascal compiler version 2.6.2 and 2.6.4.
644 The Objective C implementation of mal has been built and tested on
645 Linux using clang/LLVM 3.6. It has also been built and tested on OS
662 ### MatLab (GNU Octave and MATLAB)
664 The MatLab implementation has been tested with GNU Octave 4.2.1.
665 It has also been tested with MATLAB version R2014a on Linux. Note that
666 MATLAB is a commercial product.
671 octave -q --no-gui --no-history --eval "stepX_YYY();quit;"
672 matlab -nodisplay -nosplash -nodesktop -nojvm -r "stepX_YYY();quit;"
673 # OR with command line arguments
674 octave -q --no-gui --no-history --eval "stepX_YYY('arg1','arg2');quit;"
675 matlab -nodisplay -nosplash -nodesktop -nojvm -r "stepX_YYY('arg1','arg2');quit;"
680 [miniMAL](https://github.com/kanaka/miniMAL) is small Lisp interpreter
681 implemented in less than 1024 bytes of JavaScript. To run the miniMAL
682 implementation of mal you need to download/install the miniMAL
683 interpreter (which requires Node.js).
686 # Download miniMAL and dependencies
688 export PATH=`pwd`/node_modules/minimal-lisp/:$PATH
689 # Now run mal implementation in miniMAL
695 For readline line editing support, install Term::ReadLine::Perl or
696 Term::ReadLine::Gnu from CPAN.
705 The Perl 6 implementation was tested on Rakudo Perl 6 2016.04.
714 The PHP implementation of mal requires the php command line interface
724 The Picolisp implementation requires libreadline and Picolisp 3.1.11
732 ### PL/pgSQL (Postgres SQL Procedural Language)
734 The PL/pgSQL implementation of mal requires a running Postgres server
735 (the "kanaka/mal-test-plpgsql" docker image automatically starts
736 a Postgres server). The implementation connects to the Postgres server
737 and create a database named "mal" to store tables and stored
738 procedures. The wrapper script uses the psql command to connect to the
739 server and defaults to the user "postgres" but this can be overridden
740 with the PSQL_USER environment variable. A password can be specified
741 using the PGPASSWORD environment variable. The implementation has been
742 tested with Postgres 9.4.
746 ./wrap.sh stepX_YYY.sql
748 PSQL_USER=myuser PGPASSWORD=mypass ./wrap.sh stepX_YYY.sql
751 ### PL/SQL (Oracle SQL Procedural Language)
753 The PL/pgSQL implementation of mal requires a running Oracle DB
754 server (the "kanaka/mal-test-plsql" docker image automatically
755 starts an Oracle Express server). The implementation connects to the
756 Oracle server to create types, tables and stored procedures. The
757 default SQL*Plus logon value (username/password@connect_identifier) is
758 "system/oracle" but this can be overridden with the ORACLE_LOGON
759 environment variable. The implementation has been tested with Oracle
760 Express Edition 11g Release 2. Note that any SQL*Plus connection
761 warnings (user password expiration, etc) will interfere with the
762 ability of the wrapper script to communicate with the DB.
766 ./wrap.sh stepX_YYY.sql
768 ORACLE_LOGON=myuser/mypass@ORCL ./wrap.sh stepX_YYY.sql
771 ### Postscript Level 2/3
773 The Postscript implementation of mal requires ghostscript to run. It
774 has been tested with ghostscript 9.10.
778 gs -q -dNODISPLAY -I./ stepX_YYY.ps
783 The PowerShell implementation of mal requires the PowerShell script
784 language. It has been tested with PowerShell 6.0.0 Alpha 9 on Linux.
788 powershell ./stepX_YYY.ps1
791 ### Python (2.X and 3.X)
800 You must have [rpython](https://rpython.readthedocs.org/) on your path
801 (included with [pypy](https://bitbucket.org/pypy/pypy/)).
805 make # this takes a very long time
811 The R implementation of mal requires R (r-base-core) to run.
815 make libs # to download and build rdyncall
821 The Racket implementation of mal requires the Racket
822 compiler/interpreter to run.
831 The Rexx implementation of mal has been tested with Regina Rexx 3.6.
836 rexx -a ./stepX_YYY.rexxpp
846 ### Rust (1.0.0 nightly)
848 The rust implementation of mal requires the rust compiler and build
849 tool (cargo) to build.
853 cargo run --release --bin stepX_YYY
858 Install scala and sbt (http://www.scala-sbt.org/0.13/tutorial/Installing-sbt-on-Linux.html):
862 sbt 'run-main stepX_YYY'
865 scala -classpath target/scala*/classes stepX_YYY
868 ### Scheme (R7RS) ###
870 The Scheme implementation of mal has been tested with Chibi-Scheme
871 0.7.3, Kawa 2.4, Gauche 0.9.5, CHICKEN 4.11.0, Sagittarius 0.8.3,
872 Cyclone 0.6.3 (Git version) and Foment 0.4 (Git version). You should
873 be able to get it running on other conforming R7RS implementations
874 after figuring out how libraries are loaded and adjusting the
875 `Makefile` and `run` script accordingly.
881 scheme_MODE=chibi ./run
884 scheme_MODE=kawa ./run
886 scheme_MODE=gauche ./run
889 scheme_MODE=chicken ./run
891 scheme_MODE=sagittarius ./run
894 scheme_MODE=cyclone ./run
896 scheme_MODE=foment ./run
901 The Skew implementation of mal has been tested with Skew 0.7.42.
912 The Swift implementation of mal requires the Swift 2.0 compiler (XCode
913 7.0) to build. Older versions will not work due to changes in the
914 language and standard library.
924 The Swift 3 implementation of mal requires the Swift 3.0 compiler. It
925 has been tested with Swift 3 Preview 3.
935 The Tcl implementation of mal requires Tcl 8.6 to run. For readline line
936 editing support, install tclreadline.
940 tclsh ./stepX_YYY.tcl
945 The TypeScript implementation of mal requires the TypeScript 2.2 compiler.
946 It has been tested with Node.js v6.
956 The VHDL implementation of mal has been tested with GHDL 0.29.
961 ./run_vhdl.sh ./stepX_YYY
966 The Vimscript implementation of mal requires Vim 8.0 to run.
970 ./run_vimscript.sh ./stepX_YYY.vim
973 ### Visual Basic.NET ###
975 The VB.NET implementation of mal has been tested on Linux using the Mono
976 VB compiler (vbnc) and the Mono runtime (version 2.10.8.1). Both are
977 required to build and run the VB.NET implementation.
985 ### WebAssembly (wasm) ###
987 The WebAssembly implementation is written in
988 [Wam](https://github.com/kanaka/wam) (WebAssembly Macro language) and
989 runs under the [wac/wace](https://github.com/kanaka/wac) WebAssembly
995 wace ./stepX_YYY.wasm
1000 The Yorick implementation of mal was tested on Yorick 2.2.04.
1004 yorick -batch ./stepX_YYY.i
1011 The top level Makefile has a number of useful targets to assist with
1012 implementation development and testing. The `help` target provides
1013 a list of the targets and options:
1019 ### Functional tests
1021 The are over 600 generic functional tests (for all implementations)
1022 in the `tests/` directory. Each step has a corresponding test file
1023 containing tests specific to that step. The `runtest.py` test harness
1024 launches a Mal step implementation and then feeds the tests one at
1025 a time to the implementation and compares the output/return value to
1026 the expected output/return value.
1028 * To run all the tests across all implementations (be prepared to wait):
1034 * To run all tests against a single implementation:
1044 * To run tests for a single step against all implementations:
1054 * To run tests for a specific step against a single implementation:
1057 make "test^IMPL^stepX"
1060 make "test^ruby^step3"
1061 make "test^ps^step4"
1064 ### Self-hosted functional tests
1066 * To run the functional tests in self-hosted mode, you specify `mal`
1067 as the test implementation and use the `MAL_IMPL` make variable
1068 to change the underlying host language (default is JavaScript):
1070 make MAL_IMPL=IMPL "test^mal^step2"
1073 make "test^mal^step2" # js is default
1074 make MAL_IMPL=ruby "test^mal^step2"
1075 make MAL_IMPL=python "test^mal^step2"
1078 ### Starting the REPL
1080 * To start the REPL of an implementation in a specific step:
1083 make "repl^IMPL^stepX"
1086 make "repl^ruby^step3"
1087 make "repl^ps^step4"
1090 * If you omit the step, then `stepA` is used:
1100 * To start the REPL of the self-hosted implementation, specify `mal` as the
1101 REPL implementation and use the `MAL_IMPL` make variable to change the
1102 underlying host language (default is JavaScript):
1104 make MAL_IMPL=IMPL "repl^mal^stepX"
1107 make "repl^mal^step2" # js is default
1108 make MAL_IMPL=ruby "repl^mal^step2"
1109 make MAL_IMPL=python "repl^mal"
1112 ### Performance tests
1114 Warning: These performance tests are neither statistically valid nor
1115 comprehensive; runtime performance is a not a primary goal of mal. If
1116 you draw any serious conclusions from these performance tests, then
1117 please contact me about some amazing oceanfront property in Kansas
1118 that I'm willing to sell you for cheap.
1120 * To run performance tests against a single implementation:
1128 * To run performance tests against all implementations:
1133 ### Generating language statistics
1135 * To report line and byte statistics for a single implementation:
1143 * To report line and bytes statistics for general Lisp code (env, core
1146 make "stats-lisp^IMPL"
1149 make "stats-lisp^js"
1152 ## Dockerized testing
1154 Every implementation directory contains a Dockerfile to create
1155 a docker image containing all the dependencies for that
1156 implementation. In addition, the top-level Makefile contains support
1157 for running the tests target (and perf, stats, repl, etc) within
1158 a docker container for that implementation by passing *"DOCKERIZE=1"*
1159 on the make command line. For example:
1162 make DOCKERIZE=1 "test^js^step3"
1165 Existing implementations already have docker images built and pushed
1166 to the docker registry. However, if
1167 you wish to build or rebuild a docker image locally, the toplevel
1168 Makefile provides a rule for building docker images:
1171 make "docker-build^IMPL"
1176 * Docker images are named *"kanaka/mal-test-IMPL"*
1177 * JVM-based language implementations (Groovy, Java, Clojure, Scala):
1178 you will probably need to run this command once manually
1179 first `make DOCKERIZE=1 "repl^IMPL"` before you can run tests because
1180 runtime dependencies need to be downloaded to avoid the tests timing
1181 out. These dependencies are downloaded to dot-files in the /mal
1182 directory so they will persist between runs.
1185 ## External Implementations
1187 The following implementations are maintained as separate projects:
1191 * [by Alexander Bagnalla](https://github.com/bagnalla/holyc_mal)
1195 * [by Tim Morgan](https://github.com/seven1m/mal-rust)
1196 * [by vi](https://github.com/vi/mal-rust-vi) - using [Pest](https://pest.rs/) grammar, not using typical Mal infrastructure (cargo-ized steps and built-in converted tests).
1199 ## Other mal Projects
1201 * [malc](https://github.com/dubek/malc) - Mal (Make A Lisp) compiler. Compiles a Mal program to LLVM assembly language, then binary.
1202 * [malcc](https://git.sr.ht/~tim/malcc) (@seven1m) - malcc is an incremental compiler implementation for the Mal language. It uses the Tiny C Compiler as the compiler backend and has full support for the Mal language, including macros, tail-call elimination, and even run-time eval.
1203 * [frock](https://github.com/chr15m/frock) - Clojure-flavoured PHP. Uses mal/php to run programs.
1207 Mal (make-a-lisp) is licensed under the MPL 2.0 (Mozilla Public
1208 License 2.0). See LICENSE.txt for more details.