X-Git-Url: http://git.hcoop.net/jackhill/mal.git/blobdiff_plain/60e3f6fd6bb24ed535e70a0dc7623b7390784c17..607742f0cad69d0d0084b8f030cb0ca01d41393e:/README.md

diff --git a/README.md b/README.md
index 5fbe9fdd..000272c0 100644
--- a/README.md
+++ b/README.md
@@ -6,7 +6,42 @@
 
 **1. Mal is a Clojure inspired Lisp interpreter**
 
-**2. Mal is implemented in 75 languages (76 implementations total)**
+**2. Mal is a learning tool**
+
+Each implementation of mal is separated into
+11 incremental, self-contained (and testable) steps that demonstrate
+core concepts of Lisp. The last step is capable of self-hosting
+(running the mal implementation of mal). See the [make-a-lisp process
+guide](process/guide.md).
+
+The make-a-lisp steps are:
+
+* [step0_repl](process/guide.md#step0)
+* [step1_read_print](process/guide.md#step1)
+* [step2_eval](process/guide.md#step2)
+* [step3_env](process/guide.md#step3)
+* [step4_if_fn_do](process/guide.md#step4)
+* [step5_tco](process/guide.md#step5)
+* [step6_file](process/guide.md#step6)
+* [step7_quote](process/guide.md#step7)
+* [step8_macros](process/guide.md#step8)
+* [step9_try](process/guide.md#step9)
+* [stepA_mal](process/guide.md#stepA)
+
+Each make-a-lisp step has an associated architectural diagram. That elements
+that are new for that step are highlighted in red.
+Here is the final diagram for [step A](process/guide.md#stepA):
+
+![stepA_mal architecture](process/stepA_mal.png)
+
+If you are interested in creating a mal implementation (or just
+interested in using mal for something), please drop by the #mal
+channel on freenode. In addition to the [make-a-lisp process
+guide](process/guide.md) there is also a [mal/make-a-lisp
+FAQ](docs/FAQ.md) where I attempt to answer some common questions.
+
+
+**3. Mal is implemented in 82 languages (85 different implementations and 105 runtime modes)**
 
 | Language | Creator |
 | -------- | ------- |
@@ -15,6 +50,7 @@
 | [GNU Awk](#gnu-awk) | [Miutsuru Kariya](https://github.com/kariya-mitsuru) |
 | [Bash 4](#bash-4) | [Joel Martin](https://github.com/kanaka)  |
 | [BASIC](#basic-c64-and-qbasic) (C64 & QBasic) | [Joel Martin](https://github.com/kanaka) |
+| [BBC BASIC V](#bbc-basic-v) | [Ben Harris](https://github.com/bjh21) |
 | [C](#c) | [Joel Martin](https://github.com/kanaka)  |
 | [C++](#c-1) | [Stephen Thirlwall](https://github.com/sdt) |
 | [C#](#c-2) | [Joel Martin](https://github.com/kanaka)  |
@@ -44,6 +80,7 @@
 | [Io](#io) | [Dov Murik](https://github.com/dubek) |
 | [Java](#java-17) | [Joel Martin](https://github.com/kanaka)  |
 | [JavaScript](#javascriptnode) ([Demo](http://kanaka.github.io/mal)) | [Joel Martin](https://github.com/kanaka) |
+| [jq](#jq) | [Ali MohammadPur](https://github.com/alimpfard) |
 | [Julia](#julia) | [Joel Martin](https://github.com/kanaka)  |
 | [Kotlin](#kotlin) | [Javier Fernandez-Ivern](https://github.com/ivern) |
 | [LiveScript](#livescript) | [Jos van Bakel](https://github.com/c0deaddict) |
@@ -54,73 +91,45 @@
 | [MATLAB](#matlab-gnu-octave-and-matlab) (GNU Octave & MATLAB) | [Joel Martin](https://github.com/kanaka) |
 | [miniMAL](#minimal) ([Repo](https://github.com/kanaka/miniMAL), [Demo](https://kanaka.github.io/miniMAL/)) | [Joel Martin](https://github.com/kanaka) |
 | [NASM](#nasm) | [Ben Dudson](https://github.com/bendudson) |
-| [Nim](#nim-0170) | [Dennis Felsing](https://github.com/def-) |
+| [Nim](#nim-104) | [Dennis Felsing](https://github.com/def-) |
 | [Object Pascal](#object-pascal) | [Joel Martin](https://github.com/kanaka)  |
 | [Objective C](#objective-c) | [Joel Martin](https://github.com/kanaka)  |
 | [OCaml](#ocaml-4010) | [Chris Houser](https://github.com/chouser) |
-| [Perl](#perl-58) | [Joel Martin](https://github.com/kanaka)  |
+| [Perl](#perl-5) | [Joel Martin](https://github.com/kanaka)  |
 | [Perl 6](#perl-6) | [Hinrik Örn Sigurðsson](https://github.com/hinrik) |
 | [PHP](#php-53) | [Joel Martin](https://github.com/kanaka)  |
 | [Picolisp](#picolisp) | [Vasilij Schneidermann](https://github.com/wasamasa) |
-| [PL/pgSQL](#plpgsql-postgres-sql-procedural-language) (Postgres) | [Joel Martin](https://github.com/kanaka) |
+| [Pike](#pike) | [Dov Murik](https://github.com/dubek) |
+| [PL/pgSQL](#plpgsql-postgresql-sql-procedural-language) (PostgreSQL) | [Joel Martin](https://github.com/kanaka) |
 | [PL/SQL](#plsql-oracle-sql-procedural-language) (Oracle) | [Joel Martin](https://github.com/kanaka) |
 | [PostScript](#postscript-level-23) | [Joel Martin](https://github.com/kanaka)  |
 | [PowerShell](#powershell) | [Joel Martin](https://github.com/kanaka)  |
 | [Python](#python-2x-and-3x) (2.X & 3.X) | [Joel Martin](https://github.com/kanaka) |
+| [Python #2](#python2-3x) (3.X) | [Gavin Lewis](https://github.com/epylar) |
 | [RPython](#rpython) | [Joel Martin](https://github.com/kanaka)  |
 | [R](#r) | [Joel Martin](https://github.com/kanaka)  |
 | [Racket](#racket-53) | [Joel Martin](https://github.com/kanaka)  |
 | [Rexx](#rexx) | [Dov Murik](https://github.com/dubek) |
 | [Ruby](#ruby-19) | [Joel Martin](https://github.com/kanaka)  |
-| [Rust](#rust-100-nightly) | [Joel Martin](https://github.com/kanaka)  |
+| [Rust](#rust-138) | [Joel Martin](https://github.com/kanaka)  |
 | [Scala](#scala) | [Joel Martin](https://github.com/kanaka)  |
 | [Scheme (R7RS)](#scheme-r7rs) | [Vasilij Schneidermann](https://github.com/wasamasa) |
 | [Skew](#skew) | [Dov Murik](https://github.com/dubek) |
 | [Swift 2](#swift) | [Keith Rollin](https://github.com/keith-rollin) |
 | [Swift 3](#swift-3) | [Joel Martin](https://github.com/kanaka)  |
 | [Swift 4](#swift-4) | [陆遥](https://github.com/LispLY)  |
+| [Swift 5](#swift-5) | [Oleg Montak](https://github.com/MontakOleg)  |
 | [Tcl](#tcl-86) | [Dov Murik](https://github.com/dubek) |
 | [TypeScript](#typescript) | [Masahiro Wakame](https://github.com/vvakame) |
+| [Vala](#vala) | [Simon Tatham](https://github.com/sgtatham) |
 | [VHDL](#vhdl) | [Dov Murik](https://github.com/dubek) |
 | [Vimscript](#vimscript) | [Dov Murik](https://github.com/dubek) |
 | [Visual Basic.NET](#visual-basicnet) | [Joel Martin](https://github.com/kanaka)  |
 | [WebAssembly](#webassembly-wasm) (wasm) | [Joel Martin](https://github.com/kanaka) |
+| [Wren](#wren) | [Dov Murik](https://github.com/dubek) |
+| [XSLT](#xslt) | [Ali MohammadPur](https://github.com/alimpfard) |
 | [Yorick](#yorick) | [Dov Murik](https://github.com/dubek) |
-
-
-**3. Mal is a learning tool**
-
-Each implementation of mal is separated into
-11 incremental, self-contained (and testable) steps that demonstrate
-core concepts of Lisp. The last step is capable of self-hosting
-(running the mal implementation of mal). See the [make-a-lisp process
-guide](process/guide.md). 
-
-The make-a-lisp steps are:
-
-* [step0_repl](process/guide.md#step0)
-* [step1_read_print](process/guide.md#step1)
-* [step2_eval](process/guide.md#step2)
-* [step3_env](process/guide.md#step3)
-* [step4_if_fn_do](process/guide.md#step4)
-* [step5_tco](process/guide.md#step5)
-* [step6_file](process/guide.md#step6)
-* [step7_quote](process/guide.md#step7)
-* [step8_macros](process/guide.md#step8)
-* [step9_try](process/guide.md#step9)
-* [stepA_mal](process/guide.md#stepA)
-
-Each make-a-lisp step has an associated architectural diagram. That elements
-that are new for that step are highlighted in red.
-Here is the final diagram for [step A](process/guide.md#stepA):
-
-![stepA_mal architecture](process/stepA_mal.png)
-
-If you are interesting in creating a mal implementation (or just
-interested in using mal for something), please drop by the #mal
-channel on freenode. In addition to the [make-a-lisp process
-guide](process/guide.md) there is also a [mal/make-a-lisp
-FAQ](docs/FAQ.md) where I attempt to answer some common questions.
+| [Zig](#zig) | [Josh Tobin](https://github.com/rjtobin) |
 
 
 ## Presentations
@@ -174,8 +183,9 @@ The following implementations are maintained as separate projects:
 ## Other mal Projects
 
  * [malc](https://github.com/dubek/malc) - Mal (Make A Lisp) compiler. Compiles a Mal program to LLVM assembly language, then binary.
- * [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. ["I Built a Lisp Compiler"](https://mpov.timmorgan.org/i-built-a-lisp-compiler/) post about the process.
+ * [malcc](https://github.com/seven1m/malcc) - 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. ["I Built a Lisp Compiler"](https://mpov.timmorgan.org/i-built-a-lisp-compiler/) post about the process.
  * [frock](https://github.com/chr15m/frock) - Clojure-flavoured PHP. Uses mal/php to run programs.
+ * [flk](https://github.com/chr15m/flk) - A LISP that runs wherever Bash is
 
 
 ## Implementation Details
@@ -188,7 +198,7 @@ GNAT and (optionally) make.  There are no external dependencies
 (readline not implemented).
 
 ```
-cd ada
+cd impls/ada
 make
 ./stepX_YYY
 ```
@@ -199,7 +209,7 @@ The second Ada implementation was developed with GNAT 8 and links with
 the GNU readline library.
 
 ```
-cd ada
+cd impls/ada
 make
 ./stepX_YYY
 ```
@@ -209,14 +219,14 @@ make
 The GNU awk implementation of mal has been tested with GNU awk 4.1.1.
 
 ```
-cd gawk
+cd impls/gawk
 gawk -O -f stepX_YYY.awk
 ```
 
 ### Bash 4
 
 ```
-cd bash
+cd impls/bash
 bash stepX_YYY.sh
 ```
 
@@ -232,7 +242,7 @@ has been tested with [qb64](http://www.qb64.net/).
 Generate C64 code and run it using cbmbasic:
 
 ```
-cd basic
+cd impls/basic
 make stepX_YYY.bas
 STEP=stepX_YYY ./run
 ```
@@ -240,7 +250,7 @@ STEP=stepX_YYY ./run
 Generate QBasic code and load it into qb64:
 
 ```
-cd basic
+cd impls/basic
 make MODE=qbasic stepX_YYY.bas
 ./qb64 stepX_YYY.bas
 ```
@@ -248,6 +258,22 @@ make MODE=qbasic stepX_YYY.bas
 Thanks to [Steven Syrek](https://github.com/sjsyrek) for the original
 inspiration for this implementation.
 
+### BBC BASIC V
+
+The BBC BASIC V implementation can run in the Brandy interpreter:
+
+```
+cd impls/bbc-basic
+brandy -quit stepX_YYY.bbc
+```
+
+Or in ARM BBC BASIC V under RISC OS 3 or later:
+
+```
+*Dir bbc-basic.riscos
+*Run setup
+*Run stepX_YYY
+```
 
 ### C
 
@@ -256,7 +282,7 @@ header packages): glib, libffi6, libgc, and either the libedit or GNU readline
 library.
 
 ```
-cd c
+cd impls/c
 make
 ./stepX_YYY
 ```
@@ -268,7 +294,7 @@ a readline compatible library to build. See the `cpp/README.md` for
 more details:
 
 ```
-cd cpp
+cd impls/cpp
 make
     # OR
 make CXX=clang++-3.5
@@ -283,7 +309,7 @@ C# compiler (mcs) and the Mono runtime (version 2.10.8.1). Both are
 required to build and run the C# implementation.
 
 ```
-cd cs
+cd impls/cs
 make
 mono ./stepX_YYY.exe
 ```
@@ -293,7 +319,7 @@ mono ./stepX_YYY.exe
 The ChucK implementation has been tested with ChucK 1.3.5.2.
 
 ```
-cd chuck
+cd impls/chuck
 ./run
 ```
 
@@ -303,7 +329,7 @@ For the most part the Clojure implementation requires Clojure 1.5,
 however, to pass all tests, Clojure 1.8.0-RC4 is required.
 
 ```
-cd clojure
+cd impls/clojure
 lein with-profile +stepX trampoline run
 ```
 
@@ -311,7 +337,7 @@ lein with-profile +stepX trampoline run
 
 ```
 sudo npm install -g coffee-script
-cd coffee
+cd impls/coffee
 coffee ./stepX_YYY
 ```
 
@@ -323,7 +349,7 @@ 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
+cd impls/common-lisp
 make
 ./run
 ```
@@ -333,7 +359,7 @@ make
 The Crystal implementation of mal has been tested with Crystal 0.26.1.
 
 ```
-cd crystal
+cd impls/crystal
 crystal run ./stepX_YYY.cr
     # OR
 make   # needed to run tests
@@ -346,7 +372,7 @@ The D implementation of mal was tested with GDC 4.8.  It requires the GNU
 readline library.
 
 ```
-cd d
+cd impls/d
 make
 ./stepX_YYY
 ```
@@ -356,7 +382,7 @@ make
 The Dart implementation has been tested with Dart 1.20.
 
 ```
-cd dart
+cd impls/dart
 dart ./stepX_YYY
 ```
 
@@ -368,7 +394,7 @@ and `C-d` work, `C-c` cancels the process), it is recommended to use
 `rlwrap`.
 
 ```
-cd elisp
+cd impls/elisp
 emacs -Q --batch --load stepX_YYY.el
 # with full readline support
 rlwrap emacs -Q --batch --load stepX_YYY.el
@@ -379,7 +405,7 @@ rlwrap emacs -Q --batch --load stepX_YYY.el
 The Elixir implementation of mal has been tested with Elixir 1.0.5.
 
 ```
-cd elixir
+cd impls/elixir
 mix stepX_YYY
 # Or with readline/line editing functionality:
 iex -S mix stepX_YYY
@@ -390,7 +416,7 @@ iex -S mix stepX_YYY
 The Elm implementation of mal has been tested with Elm 0.18.0
 
 ```
-cd elm
+cd impls/elm
 make stepX_YYY.js
 STEP=stepX_YYY ./run
 ```
@@ -401,7 +427,7 @@ The Erlang implementation of mal requires [Erlang/OTP R17](http://www.erlang.org
 and [rebar](https://github.com/rebar/rebar) to build.
 
 ```
-cd erlang
+cd impls/erlang
 make
     # OR
 MAL_STEP=stepX_YYY rebar compile escriptize # build individual step
@@ -415,7 +441,7 @@ The ES6 / ECMAScript 2015 implementation uses the
 JavaScript. The generated code has been tested with Node 0.12.4.
 
 ```
-cd es6
+cd impls/es6
 make
 node build/stepX_YYY.js
 ```
@@ -429,7 +455,7 @@ compiler (mcs) is also necessary to compile the readline dependency. All are
 required to build and run the F# implementation.
 
 ```
-cd fsharp
+cd impls/fsharp
 make
 mono ./stepX_YYY.exe
 ```
@@ -440,7 +466,7 @@ The Factor implementation of mal has been tested with Factor 0.97
 ([factorcode.org](http://factorcode.org)).
 
 ```
-cd factor
+cd impls/factor
 FACTOR_ROOTS=. factor -run=stepX_YYY
 ```
 
@@ -449,7 +475,7 @@ FACTOR_ROOTS=. factor -run=stepX_YYY
 The Fantom implementation of mal has been tested with Fantom 1.0.70.
 
 ```
-cd fantom
+cd impls/fantom
 make lib/fan/stepX_YYY.pod
 STEP=stepX_YYY ./run
 ```
@@ -457,14 +483,14 @@ STEP=stepX_YYY ./run
 ### Forth
 
 ```
-cd forth
+cd impls/forth
 gforth stepX_YYY.fs
 ```
 
 ### GNU Guile 2.1+
 
 ```
-cd guile
+cd impls/guile
 guile -L ./ stepX_YYY.scm
 ```
 
@@ -473,7 +499,7 @@ guile -L ./ stepX_YYY.scm
 The Smalltalk implementation of mal has been tested with GNU Smalltalk 3.2.91.
 
 ```
-cd gnu-smalltalk
+cd impls/gnu-smalltalk
 ./run
 ```
 
@@ -483,7 +509,7 @@ The Go implementation of mal requires that go is installed on on the
 path. The implementation has been tested with Go 1.3.1.
 
 ```
-cd go
+cd impls/go
 make
 ./stepX_YYY
 ```
@@ -495,7 +521,7 @@ The Groovy implementation of mal requires Groovy to run and has been
 tested with Groovy 1.8.6.
 
 ```
-cd groovy
+cd impls/groovy
 make
 groovy ./stepX_YYY.groovy
 ```
@@ -506,7 +532,7 @@ 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
+cd impls/haskell
 make
 ./stepX_YYY
 ```
@@ -518,7 +544,7 @@ Four different Haxe targets are supported: Neko, Python, C++, and
 JavaScript.
 
 ```
-cd haxe
+cd impls/haxe
 # Neko
 make all-neko
 neko ./stepX_YYY.n
@@ -538,7 +564,7 @@ node ./stepX_YYY.js
 The Hy implementation of mal has been tested with Hy 0.13.0.
 
 ```
-cd hy
+cd impls/hy
 ./stepX_YYY.hy
 ```
 
@@ -547,7 +573,7 @@ cd hy
 The Io implementation of mal has been tested with Io version 20110905.
 
 ```
-cd io
+cd impls/io
 io ./stepX_YYY.io
 ```
 
@@ -556,7 +582,7 @@ io ./stepX_YYY.io
 The Java implementation of mal requires maven2 to build.
 
 ```
-cd java
+cd impls/java
 mvn compile
 mvn -quiet exec:java -Dexec.mainClass=mal.stepX_YYY
     # OR
@@ -566,8 +592,8 @@ mvn -quiet exec:java -Dexec.mainClass=mal.stepX_YYY -Dexec.args="CMDLINE_ARGS"
 ### JavaScript/Node
 
 ```
-cd js
-npm update
+cd impls/js
+npm install
 node stepX_YYY.js
 ```
 
@@ -576,16 +602,27 @@ node stepX_YYY.js
 The Julia implementation of mal requires Julia 0.4.
 
 ```
-cd julia
+cd impls/julia
 julia stepX_YYY.jl
 ```
 
+### jq
+
+Tested against version 1.6, with a lot of cheating in the IO department
+
+```
+cd impls/jq
+STEP=stepA_YYY ./run
+    # with Debug
+DEBUG=true STEP=stepA_YYY ./run
+```
+
 ### Kotlin
 
 The Kotlin implementation of mal has been tested with Kotlin 1.0.
 
 ```
-cd kotlin
+cd impls/kotlin
 make
 java -jar stepX_YYY.jar
 ```
@@ -595,7 +632,7 @@ java -jar stepX_YYY.jar
 The LiveScript implementation of mal has been tested with LiveScript 1.5.
 
 ```
-cd livescript
+cd impls/livescript
 make
 node_modules/.bin/lsc stepX_YYY.ls
 ```
@@ -605,19 +642,18 @@ node_modules/.bin/lsc stepX_YYY.ls
 The Logo implementation of mal has been tested with UCBLogo 6.0.
 
 ```
-cd logo
+cd impls/logo
 logo stepX_YYY.lg
 ```
 
 ### Lua
 
-The Lua implementation of mal has been tested with Lua 5.2. The
-implementation requires that luarocks and the lua-rex-pcre library
-are installed.
+The Lua implementation of mal has been tested with Lua 5.3.5 The
+implementation requires luarocks to be installed.
 
 ```
-cd lua
-make  # to build and link linenoise.so
+cd impls/lua
+make  # to build and link linenoise.so and rex_pcre.so
 ./stepX_YYY.lua
 ```
 
@@ -628,7 +664,7 @@ the other implementations and passing the mal step to run as a command
 line argument.
 
 ```
-cd IMPL
+cd impls/IMPL
 IMPL_STEPA_CMD ../mal/stepX_YYY.mal
 
 ```
@@ -636,7 +672,7 @@ IMPL_STEPA_CMD ../mal/stepX_YYY.mal
 ### GNU Make 3.81
 
 ```
-cd make
+cd impls/make
 make -f stepX_YYY.mk
 ```
 
@@ -646,17 +682,17 @@ The NASM implementation of mal is written for x86-64 Linux, and has been tested
 with Linux 3.16.0-4-amd64 and NASM version 2.11.05.
 
 ```
-cd nasm
+cd impls/nasm
 make
 ./stepX_YYY
 ```
 
-### Nim 0.17.0
+### Nim 1.0.4
 
-The Nim implementation of mal has been tested with Nim 0.17.0.
+The Nim implementation of mal has been tested with Nim 1.0.4.
 
 ```
-cd nim
+cd impls/nim
 make
   # OR
 nimble build
@@ -669,7 +705,7 @@ 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
+cd impls/objpascal
 make
 ./stepX_YYY
 ```
@@ -681,7 +717,7 @@ Linux using clang/LLVM 3.6. It has also been built and tested on OS
 X using XCode 7.
 
 ```
-cd objc
+cd impls/objc
 make
 ./stepX_YYY
 ```
@@ -689,7 +725,7 @@ make
 ### OCaml 4.01.0
 
 ```
-cd ocaml
+cd impls/ocaml
 make
 ./stepX_YYY
 ```
@@ -701,7 +737,7 @@ It has also been tested with MATLAB version R2014a on Linux. Note that
 MATLAB is a commercial product.
 
 ```
-cd matlab
+cd impls/matlab
 ./stepX_YYY
 octave -q --no-gui --no-history --eval "stepX_YYY();quit;"
 matlab -nodisplay -nosplash -nodesktop -nojvm -r "stepX_YYY();quit;"
@@ -717,7 +753,7 @@ implemented in less than 1024 bytes of JavaScript. To run the miniMAL
 implementation of mal you need to download/install the miniMAL
 interpreter (which requires Node.js).
 ```
-cd miniMAL
+cd impls/miniMAL
 # Download miniMAL and dependencies
 npm install
 export PATH=`pwd`/node_modules/minimal-lisp/:$PATH
@@ -725,13 +761,15 @@ export PATH=`pwd`/node_modules/minimal-lisp/:$PATH
 miniMAL ./stepX_YYY
 ```
 
-### Perl 5.8
+### Perl 5
+
+The Perl 5 implementation should work with perl 5.19.3 and later.
 
 For readline line editing support, install Term::ReadLine::Perl or
 Term::ReadLine::Gnu from CPAN.
 
 ```
-cd perl
+cd impls/perl
 perl stepX_YYY.pl
 ```
 
@@ -740,7 +778,7 @@ perl stepX_YYY.pl
 The Perl 6 implementation was tested on Rakudo Perl 6 2016.04.
 
 ```
-cd perl6
+cd impls/perl6
 perl6 stepX_YYY.pl
 ```
 
@@ -750,7 +788,7 @@ The PHP implementation of mal requires the php command line interface
 to run.
 
 ```
-cd php
+cd impls/php
 php stepX_YYY.php
 ```
 
@@ -760,24 +798,33 @@ The Picolisp implementation requires libreadline and Picolisp 3.1.11
 or later.
 
 ```
-cd picolisp
+cd impls/picolisp
 ./run
 ```
 
-### PL/pgSQL (Postgres SQL Procedural Language)
+### Pike
+
+The Pike implementation was tested on Pike 8.0.
+
+```
+cd impls/pike
+pike stepX_YYY.pike
+```
+
+### PL/pgSQL (PostgreSQL SQL Procedural Language)
 
-The PL/pgSQL implementation of mal requires a running Postgres server
+The PL/pgSQL implementation of mal requires a running PostgreSQL server
 (the "kanaka/mal-test-plpgsql" docker image automatically starts
-a Postgres server). The implementation connects to the Postgres server
+a PostgreSQL server). The implementation connects to the PostgreSQL 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.
+tested with PostgreSQL 9.4.
 
 ```
-cd plpgsql
+cd impls/plpgsql
 ./wrap.sh stepX_YYY.sql
     # OR
 PSQL_USER=myuser PGPASSWORD=mypass ./wrap.sh stepX_YYY.sql
@@ -785,31 +832,31 @@ 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
+The PL/SQL 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
+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
+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
+cd impls/plsql
 ./wrap.sh stepX_YYY.sql
     # OR
 ORACLE_LOGON=myuser/mypass@ORCL ./wrap.sh stepX_YYY.sql
 ```
 
-### Postscript Level 2/3
+### PostScript Level 2/3
 
-The Postscript implementation of mal requires ghostscript to run. It
-has been tested with ghostscript 9.10.
+The PostScript implementation of mal requires Ghostscript to run. It
+has been tested with Ghostscript 9.10.
 
 ```
-cd ps
+cd impls/ps
 gs -q -dNODISPLAY -I./ stepX_YYY.ps
 ```
 
@@ -819,24 +866,34 @@ 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
+cd impls/powershell
 powershell ./stepX_YYY.ps1
 ```
 
 ### Python (2.X and 3.X)
 
 ```
-cd python
+cd impls/python
 python stepX_YYY.py
 ```
 
+### Python.2 (3.X)
+
+The second Python implementation makes heavy use of type annotations and uses the Arpeggio parser library.
+
+```
+# Recommended: do these steps in a Python virtual environment.
+pip3 install Arpeggio==1.9.0
+python3 stepX_YYY.py
+```
+
 ### RPython
 
 You must have [rpython](https://rpython.readthedocs.org/) on your path
 (included with [pypy](https://bitbucket.org/pypy/pypy/)).
 
 ```
-cd rpython
+cd impls/rpython
 make        # this takes a very long time
 ./stepX_YYY
 ```
@@ -846,7 +903,7 @@ make        # this takes a very long time
 The R implementation of mal requires R (r-base-core) to run.
 
 ```
-cd r
+cd impls/r
 make libs  # to download and build rdyncall
 Rscript stepX_YYY.r
 ```
@@ -857,7 +914,7 @@ The Racket implementation of mal requires the Racket
 compiler/interpreter to run.
 
 ```
-cd racket
+cd impls/racket
 ./stepX_YYY.rkt
 ```
 
@@ -866,7 +923,7 @@ cd racket
 The Rexx implementation of mal has been tested with Regina Rexx 3.6.
 
 ```
-cd rexx
+cd impls/rexx
 make
 rexx -a ./stepX_YYY.rexxpp
 ```
@@ -874,17 +931,17 @@ rexx -a ./stepX_YYY.rexxpp
 ### Ruby (1.9+)
 
 ```
-cd ruby
+cd impls/ruby
 ruby stepX_YYY.rb
 ```
 
-### Rust (1.0.0 nightly)
+### Rust (1.38+)
 
 The rust implementation of mal requires the rust compiler and build
 tool (cargo) to build.
 
 ```
-cd rust
+cd impls/rust
 cargo run --release --bin stepX_YYY
 ```
 
@@ -893,7 +950,7 @@ cargo run --release --bin stepX_YYY
 Install scala and sbt (http://www.scala-sbt.org/0.13/tutorial/Installing-sbt-on-Linux.html):
 
 ```
-cd scala
+cd impls/scala
 sbt 'run-main stepX_YYY'
     # OR
 sbt compile
@@ -910,7 +967,7 @@ after figuring out how libraries are loaded and adjusting the
 `Makefile` and `run` script accordingly.
 
 ```
-cd scheme
+cd impls/scheme
 make symlinks
 # chibi
 scheme_MODE=chibi ./run
@@ -936,7 +993,7 @@ scheme_MODE=foment ./run
 The Skew implementation of mal has been tested with Skew 0.7.42.
 
 ```
-cd skew
+cd impls/skew
 make
 node stepX_YYY.js
 ```
@@ -949,7 +1006,7 @@ The Swift implementation of mal requires the Swift 2.0 compiler (XCode
 language and standard library.
 
 ```
-cd swift
+cd impls/swift
 make
 ./stepX_YYY
 ```
@@ -960,7 +1017,7 @@ The Swift 3 implementation of mal requires the Swift 3.0 compiler. It
 has been tested with Swift 3 Preview 3.
 
 ```
-cd swift3
+cd impls/swift3
 make
 ./stepX_YYY
 ```
@@ -971,18 +1028,28 @@ The Swift 4 implementation of mal requires the Swift 4.0 compiler. It
 has been tested with Swift 4.2.3 release.
 
 ```
-cd swift4
+cd impls/swift4
 make
 ./stepX_YYY
 ```
 
+### Swift 5
+
+The Swift 5 implementation of mal requires the Swift 5.0 compiler. It
+has been tested with Swift 5.1.1 release.
+
+```
+cd impls/swift5
+swift run stepX_YYY
+```
+
 ### Tcl 8.6
 
 The Tcl implementation of mal requires Tcl 8.6 to run.  For readline line
 editing support, install tclreadline.
 
 ```
-cd tcl
+cd impls/tcl
 tclsh ./stepX_YYY.tcl
 ```
 
@@ -992,17 +1059,29 @@ The TypeScript implementation of mal requires the TypeScript 2.2 compiler.
 It has been tested with Node.js v6.
 
 ```
-cd ts
+cd impls/ts
 make
 node ./stepX_YYY.js
 ```
 
+### Vala
+
+The Vala implementation of mal has been tested with the Vala 0.40.8
+compiler. You will need to install `valac` and `libreadline-dev` or
+equivalent.
+
+```
+cd impls/vala
+make
+./stepX_YYY
+```
+
 ### VHDL
 
 The VHDL implementation of mal has been tested with GHDL 0.29.
 
 ```
-cd vhdl
+cd impls/vhdl
 make
 ./run_vhdl.sh ./stepX_YYY
 ```
@@ -1012,7 +1091,7 @@ make
 The Vimscript implementation of mal requires Vim 8.0 to run.
 
 ```
-cd vimscript
+cd impls/vimscript
 ./run_vimscript.sh ./stepX_YYY.vim
 ```
 
@@ -1023,7 +1102,7 @@ VB compiler (vbnc) and the Mono runtime (version 2.10.8.1). Both are
 required to build and run the VB.NET implementation.
 
 ```
-cd vb
+cd impls/vb
 make
 mono ./stepX_YYY.exe
 ```
@@ -1033,23 +1112,31 @@ mono ./stepX_YYY.exe
 The WebAssembly implementation is written in
 [Wam](https://github.com/kanaka/wam) (WebAssembly Macro language) and
 runs under several different non-web embeddings (runtimes):
-node,
+[node](https://nodejs.org),
 [wasmtime](https://github.com/CraneStation/wasmtime),
+[wasmer](https://wasmer.io),
+[lucet](https://github.com/fastly/lucet),
 [wax](https://github.com/kanaka/wac),
 [wace](https://github.com/kanaka/wac),
 [warpy](https://github.com/kanaka/warpy).
 
 ```
-cd wasm
+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
+# lucet
+make wasm_MODE=lucet
+lucet-wasi --dir=./:./ --dir=../:../ --dir=/:/ ./stepX_YYY.so
 # wax
 make wasm_MODE=wax
-wace ./stepX_YYY.wasm
+wax ./stepX_YYY.wasm
 # wace
 make wasm_MODE=wace_libc
 wace ./stepX_YYY.wasm
@@ -1058,15 +1145,42 @@ make wasm_MODE=warpy
 warpy --argv --memory-pages 256 ./stepX_YYY.wasm
 ```
 
+### XSLT
+
+The XSLT implementation of mal is written with XSLT 3 and tested on Saxon 9.9.1.6 Home Edition.
+
+```
+cd impls/xslt
+STEP=stepX_YY ./run
+```
+
+### Wren
+
+The Wren implementation of mal was tested on Wren 0.2.0.
+
+```
+cd impls/wren
+wren ./stepX_YYY.wren
+```
+
 ### Yorick
 
 The Yorick implementation of mal was tested on Yorick 2.2.04.
 
 ```
-cd yorick
+cd impls/yorick
 yorick -batch ./stepX_YYY.i
 ```
 
+### Zig
+
+The Zig implementation of mal was tested on Zig 0.5.
+
+```
+cd impls/zig
+zig build stepX_YYY
+```
+
 
 
 ## Running tests
@@ -1081,7 +1195,7 @@ make help
 
 ### Functional tests
 
-The are over 600 generic functional tests (for all implementations)
+The are almost 800 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