Mal is a Clojure inspired Lisp interpreter.
-Mal is implemented in 48 languages:
+Mal is implemented in 69 languages:
+* Ada
* GNU awk
* Bash shell
+* BASIC (C64 and QBasic)
* C
* C++
* C#
-* Clojure
+* ChucK
+* Common Lisp
+* Clojure (Clojure and ClojureScript)
* CoffeeScript
* Crystal
* D
+* Dart
* Elixir
+* Elm
* Emacs Lisp
* Erlang
* ES6 (ECMAScript 6 / ECMAScript 2015)
* Go
* Groovy
* GNU Guile
+* GNU Smalltalk
* Haskell
-* Haxe
+* Haxe (Neko, Python, C++ and JavaScript)
+* Io
* Java
* JavaScript ([Online Demo](http://kanaka.github.io/mal))
* Julia
* Kotlin
+* LiveScript
+* Logo
* Lua
* GNU Make
* mal itself
-* MATLAB
+* Matlab (GNU Octave and MATLAB)
* [miniMAL](https://github.com/kanaka/miniMAL)
* Nim
+* Object Pascal
* Objective C
* OCaml
* Perl
+* Perl 6
* PHP
+* Picolisp
+* PL/pgSQL (Postgres)
+* PL/SQL (Oracle)
* Postscript
-* Python
+* PowerShell
+* Python (2.X and 3.X)
* RPython
* R
* Racket
+* Rexx
* Ruby
* Rust
* Scala
+* Scheme (R7RS)
+* Skew
* Swift
* Swift 3
* Tcl
+* TypeScript
+* VHDL
* Vimscript
* Visual Basic.NET
Mal was presented publicly for the first time in a lightning talk at
Clojure West 2014 (unfortunately there is no video). See
-mal/clojurewest2014.mal for the presentation that was given at the
-conference (yes the presentation is a mal program).
+examples/clojurewest2014.mal for the presentation that was given at the
+conference (yes the presentation is a mal program). At Midwest.io
+2015, Joel Martin gave a presentation on Mal titled "Achievement
+Unlocked: A Better Path to Language Learning".
+[Video](https://www.youtube.com/watch?v=lgyOAiRtZGw),
+[Slides](http://kanaka.github.io/midwest.io.mal/). More recently
+Joel gave a presentation on "Make Your Own Lisp Interpreter in
+10 Incremental Steps" at LambdaConf 2016: [Part
+1](https://www.youtube.com/watch?v=jVhupfthTEk), [Part
+2](https://www.youtube.com/watch?v=X5OQBMGpaTU),
+[Slides](http://kanaka.github.io/lambdaconf/).
If you are interesting in creating a mal implementation (or just
interested in using mal for something), please drop by the #mal
## Building/running implementations
+The simplest way to run any given implementation is to use docker.
+Every implementation has a docker image pre-built with language
+dependencies installed. You can launch the REPL using a convenience
+target in the top level Makefile (where IMPL is the implementation
+directory name and stepX is the step to run):
+
+```
+make DOCKERIZE=1 "repl^IMPL^stepX"
+ # OR stepA is the default step:
+make DOCKERIZE=1 "repl^IMPL"
+```
+
+
+### Ada
+
+*The Ada implementation was created by [Chris Moore](https://github.com/zmower)*
+
+The Ada implementation was developed with GNAT 4.9 on debian. It also
+compiles unchanged on windows if you have windows versions of git,
+GNAT and (optionally) make. There are no external dependencies
+(readline not implemented).
+
+```
+cd ada
+make
+./stepX_YYY
+```
+
### GNU awk
*The GNU awk implementation was created by [Miutsuru kariya](https://github.com/kariya-mitsuru)*
bash stepX_YYY.sh
```
+### BASIC (C64 and QBasic)
+
+The BASIC implementation uses a preprocessor that can generate BASIC
+code that is compatible with both C64 BASIC (CBM v2) and QBasic. The
+C64 mode has been tested with
+[cbmbasic](https://github.com/kanaka/cbmbasic) (the patched version is
+currently required to fix issues with line input) and the QBasic mode
+has been tested with [qb64](http://www.qb64.net/).
+
+Generate C64 code and run it using cbmbasic:
+
+```
+cd basic
+make stepX_YYY.bas
+STEP=stepX_YYY ./run
+```
+
+Generate QBasic code and load it into qb64:
+
+```
+cd basic
+make MODE=qbasic stepX_YYY.bas
+./qb64 stepX_YYY.bas
+```
+
+Thanks to [Steven Syrek](https://github.com/sjsyrek) for the original
+inspiration for this implementation.
+
+
### C
The C implementation of mal requires the following libraries (lib and
-header packages): glib, libffi6 and either the libedit or GNU readline library.
+header packages): glib, libffi6, libgc, and either the libedit or GNU readline
+library.
```
cd c
mono ./stepX_YYY.exe
```
+### ChucK
+
+*The ChucK implementation was created by [Vasilij Schneidermann](https://github.com/wasamasa)*
+
+The ChucK implementation has been tested with ChucK 1.3.5.2.
+
+```
+cd chuck
+./run
+```
+
+### Common Lisp
+
+*The Common Lisp implementation was created by [Iqbal Ansari](https://github.com/iqbalansari)*
+
+The implementation has been tested with SBCL, CCL, CMUCL, GNU CLISP, ECL and
+Allegro CL on Ubuntu 16.04 and Ubuntu 12.04, see
+the [README][common-lisp/README.org] for more details. Provided you have the
+dependencies mentioned installed, do the following to run the implementation
+
+```
+cd common-lisp
+make
+./run
+```
### Clojure
*The Crystal implementation of mal was created by [Linda_pp](https://github.com/rhysd)*
-The Crystal implementation of mal has been tested with Crystal 0.10.0.
+The Crystal implementation of mal has been tested with Crystal 0.18.4.
```
cd crystal
./stepX_YYY
```
+### Dart
+
+*The Dart implementation was created by [Harry Terkelsen](https://github.com/hterkelsen)*
+
+The Dart implementation has been tested with Dart 1.20.
+
+```
+cd dart
+dart ./stepX_YYY
+```
+
### Emacs Lisp
*The Emacs Lisp implementation was created by [Vasilij Schneidermann](https://github.com/wasamasa)*
iex -S mix stepX_YYY
```
+### Elm
+
+*The Elm implementation was created by [Jos van Bakel](https://github.com/c0deaddict)*
+
+The Elm implementation of mal has been tested with Elm 0.18.0
+
+```
+cd elm
+make stepX_YYY.js
+STEP=stepX_YYY ./run
+```
+
### Erlang
*The Erlang implementation was created by [Nathan Fiedler (nlfiedler)](https://github.com/nlfiedler)*
*The Factor implementation was created by [Jordan Lewis (jordanlewis)](https://github.com/jordanlewis)*
The Factor implementation of mal has been tested with Factor 0.97
-([factorcode.org](factorcode.org)).
+([factorcode.org](http://factorcode.org)).
```
cd factor
guile -L ./ stepX_YYY.scm
```
+### GNU Smalltalk
+
+*The Smalltalk implementation was created by [Vasilij Schneidermann](https://github.com/wasamasa)*
+
+The Smalltalk implementation of mal has been tested with GNU Smalltalk 3.2.91.
+
+```
+cd gst
+./run
+```
+
### Haskell
-Install the Haskell compiler (ghc/ghci), the Haskell platform and
-either the editline package (BSD) or the readline package (GPL). On
-Ubuntu these packages are: ghc, haskell-platform,
-libghc-readline-dev/libghc-editline-dev
+The Haskell implementation requires the ghc compiler version 7.10.1 or
+later and also the Haskell parsec and readline (or editline) packages.
```
cd haskell
./stepX_YYY
```
-### Haxe
+### Haxe (Neko, Python, C++ and JavaScript)
The Haxe implementation of mal requires Haxe version 3.2 to compile.
Four different Haxe targets are supported: Neko, Python, C++, and
node ./stepX_YYY.js
```
+### Io
+
+*The Io implementation was created by [Dov Murik](https://github.com/dubek)*
+
+The Io implementation of mal has been tested with Io version 20110905.
+
+```
+cd io
+io ./stepX_YYY.io
+```
### Java 1.7
java -jar stepX_YYY.jar
```
+### LiveScript
+
+*The LiveScript implementation was created by [Jos van Bakel](https://github.com/c0deaddict)*
+
+The LiveScript implementation of mal has been tested with LiveScript 1.5.
+
+```
+cd livescript
+make
+node_modules/.bin/lsc stepX_YYY.ls
+```
+
+### Logo
+
+*The Logo implementation was created by [Dov Murik](https://github.com/dubek)*
+
+The Logo implementation of mal has been tested with UCBLogo 6.0.
+
+```
+cd logo
+logo stepX_YYY.lg
+```
+
### Lua
Running the Lua implementation of mal requires lua 5.1 or later,
make -f stepX_YYY.mk
```
-### Nim 0.11.0
+### Nim 0.17.0
*The Nim implementation was created by [Dennis Felsing (def-)](https://github.com/def-)*
-Running the Nim implementation of mal requires Nim 0.11.0 or later.
+The Nim implementation of mal has been tested with Nim 0.17.0.
```
cd nim
./stepX_YYY
```
+### Object Pascal
+
+The Object Pascal implementation of mal has been built and tested on
+Linux using the Free Pascal compiler version 2.6.2 and 2.6.4.
+
+```
+cd objpascal
+make
+./stepX_YYY
+```
+
### Objective C
The Objective C implementation of mal has been built and tested on
./stepX_YYY
```
-### MATLAB
+### MatLab (GNU Octave and MATLAB)
-The MATLAB implementation of mal has been tested with MATLAB version
-R2014a on Linux. Note that MATLAB is a commercial product. It should
-be fairly simple to support GNU Octave once it support classdef object
-syntax.
+The MatLab implementation has been tested with GNU Octave 4.2.1.
+It has also been tested with MATLAB version R2014a on Linux. Note that
+MATLAB is a commercial product.
```
cd 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;"
```
perl stepX_YYY.pl
```
+### Perl 6
+
+*The Perl 6 implementation was created by [Hinrik Örn Sigurðsson](https://github.com/hinrik)*
+
+The Perl 6 implementation was tested on Rakudo Perl 6 2016.04.
+
+```
+cd perl6
+perl6 stepX_YYY.pl
+```
### PHP 5.3
php stepX_YYY.php
```
+### Picolisp
+
+*The Picolisp implementation was created by [Vasilij Schneidermann](https://github.com/wasamasa)*
+
+The Picolisp implementation requires libreadline and Picolisp 3.1.11
+or later.
+
+```
+cd pil
+./run
+```
+
+### PL/pgSQL (Postgres SQL Procedural Language)
+
+The PL/pgSQL implementation of mal requires a running Postgres server
+(the "kanaka/mal-test-plpgsql" docker image automatically starts
+a Postgres server). The implementation connects to the Postgres server
+and create a database named "mal" to store tables and stored
+procedures. The wrapper script uses the psql command to connect to the
+server and defaults to the user "postgres" but this can be overridden
+with the PSQL_USER environment variable. A password can be specified
+using the PGPASSWORD environment variable. The implementation has been
+tested with Postgres 9.4.
+
+```
+cd plpgsql
+./wrap.sh stepX_YYY.sql
+ # OR
+PSQL_USER=myuser PGPASSWORD=mypass ./wrap.sh stepX_YYY.sql
+```
+
+### PL/SQL (Oracle SQL Procedural Language)
+
+The PL/pgSQL implementation of mal requires a running Oracle DB
+server (the "kanaka/mal-test-plsql" docker image automatically
+starts an Oracle Express server). The implementation connects to the
+Oracle server to create types, tables and stored procedures. The
+default SQL*Plus logon value (username/password@connect_identifier) is
+"system/oracle" but this can be overridden with the ORACLE_LOGON
+environment variable. The implementation has been tested with Oracle
+Express Edition 11g Release 2. Note that any SQL*Plus connection
+warnings (user password expiration, etc) will interfere with the
+ability of the wrapper script to communicate with the DB.
+
+```
+cd plsql
+./wrap.sh stepX_YYY.sql
+ # OR
+ORACLE_LOGON=myuser/mypass@ORCL ./wrap.sh stepX_YYY.sql
+```
+
### Postscript Level 2/3
The Postscript implementation of mal requires ghostscript to run. It
gs -q -dNODISPLAY -I./ stepX_YYY.ps
```
-### Python (2.X or 3.X)
+### PowerShell
+
+The PowerShell implementation of mal requires the PowerShell script
+language. It has been tested with PowerShell 6.0.0 Alpha 9 on Linux.
+
+```
+cd powershell
+powershell ./stepX_YYY.ps1
+```
+
+### Python (2.X and 3.X)
```
cd python
./stepX_YYY.rkt
```
+### Rexx
+
+*The Rexx implementation was created by [Dov Murik](https://github.com/dubek)*
+
+The Rexx implementation of mal has been tested with Regina Rexx 3.6.
+
+```
+cd rexx
+make
+rexx -a ./stepX_YYY.rexxpp
+```
+
### Ruby (1.9+)
```
scala -classpath target/scala*/classes stepX_YYY
```
+### Scheme (R7RS) ###
+
+*The Scheme implementation was created by [Vasilij Schneidermann](https://github.com/wasamasa)*
+
+The Scheme implementation of mal has been tested with Chibi-Scheme
+0.7.3, Kawa 2.4, Gauche 0.9.5, CHICKEN 4.11.0, Sagittarius 0.8.3,
+Cyclone 0.6.3 (Git version) and Foment 0.4 (Git version). You should
+be able to get it running on other conforming R7RS implementations
+after figuring out how libraries are loaded and adjusting the
+`Makefile` and `run` script accordingly.
+
+```
+cd scheme
+make symlinks
+# 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
+```
+
+### Skew ###
+
+*The Skew implementation was created by [Dov Murik](https://github.com/dubek)*
+
+The Skew implementation of mal has been tested with Skew 0.7.42.
+
+```
+cd skew
+make
+node stepX_YYY.js
+```
+
+
### Swift
*The Swift implementation was created by [Keith Rollin](https://github.com/keith-rollin)*
### Swift 3
The Swift 3 implementation of mal requires the Swift 3.0 compiler. It
-has been tested with the development version of the Swift 3 from
-2016-02-08.
+has been tested with Swift 3 Preview 3.
```
cd swift3
tclsh ./stepX_YYY.tcl
```
+### TypeScript
+
+*The TypeScript implementation was created by [vvakame](https://github.com/vvakame)*
+
+The TypeScript implementation of mal requires the TypeScript 2.2 compiler.
+It has been tested with Node.js v6.
+
+```
+cd ts
+make
+node ./stepX_YYY.js
+```
+
+### VHDL
+
+*The VHDL implementation was created by [Dov Murik](https://github.com/dubek)*
+
+The VHDL implementation of mal has been tested with GHDL 0.29.
+
+```
+cd vhdl
+make
+./run_vhdl.sh ./stepX_YYY
+```
+
### Vimscript
*The Vimscript implementation was created by [Dov Murik](https://github.com/dubek)*
-The Vimscript implementation of mal requires Vim to run. It has been tested
-with Vim 7.4.
+The Vimscript implementation of mal requires Vim 8.0 to run.
```
cd vimscript
### Functional tests
-The are nearly 500 generic functional tests (for all implementations)
+The are over 600 generic functional tests (for all implementations)
in the `tests/` directory. Each step has a corresponding test file
containing tests specific to that step. The `runtest.py` test harness
launches a Mal step implementation and then feeds the tests one at
make "stats-lisp^js"
```
-## Docker test environment
+## Dockerized testing
-There is a Dockerfile included in the `tests/docker` directory that
-builds a docker image based on Ubuntu Utopic that contains everything
-needed to run tests against all the implementations (except for MATLAB
-which is proprietary/licensed).
+Every implementation directory contains a Dockerfile to create
+a docker image containing all the dependencies for that
+implementation. In addition, the top-level Makefile contains support
+for running the tests target (and perf, stats, repl, etc) within
+a docker container for that implementation by passing *"DOCKERIZE=1"*
+on the make command line. For example:
-Build the docker image using a provided script. WARNING: this will
-likely take over an hour to build from scratch and use more 3 GB of disk:
-```bash
-./tests/docker-build.sh
```
-
-Launch a docker container from that image built above. This will
-volume mount the mal directory to `/mal` and then give you a bash
-prompt in the container. You can then run individual mal
-implementations and tests:
-```bash
-./tests/docker-run.sh
+make DOCKERIZE=1 "test^js^step3"
```
-You can also specify a command to run within the container. For
-example, to run step2 tests for every implementation (except MATLAB):
-```bash
-./tests/docker-run.sh make SKIP_IMPLS="matlab" "test^step2"
+Existing implementations already have docker images built and pushed
+to the docker registry. However, if
+you wish to build or rebuild a docker image locally, the toplevel
+Makefile provides a rule for building docker images:
+
```
+make "docker-build^IMPL"
+```
+
**Notes**:
-* JVM-based language implementations (Java, Clojure, Scala): you will
- need to run these implementations once manually first before you can
- run tests because runtime dependencies need to be downloaded to
- avoid the tests timing out. These dependencies are download to
- dot-files in the /mal directory so they will persist between runs.
-* Compiled languages: if your host system is different enough from
- Ubuntu Utopic then you may need to re-compile your compiled
- languages from within the container to avoid linker version
- mismatches.
+* Docker images are named *"kanaka/mal-test-IMPL"*
+* JVM-based language implementations (Groovy, Java, Clojure, Scala):
+ you will probably need to run these implementations once manually
+ first (make DOCKERIZE=1 "repl^IMPL")before you can run tests because
+ runtime dependencies need to be downloaded to avoid the tests timing
+ out. These dependencies are download to dot-files in the /mal
+ directory so they will persist between runs.
## License
HCoop / jackhill / mal.git / blobdiff